src/bindings/java/jmsg_task.cpp

   1 /* Functions related to the java task instances.                            */
   2
   3 /* Copyright (c) 2007-2019. The SimGrid Team. All rights reserved.          */
   4
   5 /* This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the license (GNU LGPL) which comes with this package. */
   7
   8 #include "simgrid/s4u/Host.hpp"
   9 #include "src/kernel/context/Context.hpp"
  10
  11 #include "jmsg.hpp"
  12 #include "jmsg_host.h"
  13 #include "jmsg_process.h"
  14 #include "jmsg_task.h"
  15 #include "jxbt_utilities.hpp"
  16
  17 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(java);
  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(jobject jtask, JNIEnv* env)
  34 {
  35   return (msg_task_t)(intptr_t)env->GetLongField(jtask, jtask_field_Task_bind);
  36 }
  37
  38 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_nativeInit(JNIEnv *env, jclass cls) {
  39   jclass jtask_class_Comm = env->FindClass("org/simgrid/msg/Comm");
  40   jclass jtask_class_Task = env->FindClass("org/simgrid/msg/Task");
  41   xbt_assert(jtask_class_Comm && jtask_class_Task,
  42              "Native initialization of msg/Comm or msg/Task failed. Please report that bug");
  43
  44   jtask_method_Comm_constructor = env->GetMethodID(jtask_class_Comm, "<init>", "()V");
  45   jtask_field_Task_bind = jxbt_get_jfield(env, jtask_class_Task, "bind", "J");
  46   jtask_field_Task_name = jxbt_get_jfield(env, jtask_class_Task, "name", "Ljava/lang/String;");
  47   jtask_field_Task_messageSize = jxbt_get_jfield(env, jtask_class_Task, "messageSize", "D");
  48   jtask_field_Comm_bind = jxbt_get_jfield(env, jtask_class_Comm, "bind", "J");
  49   jtask_field_Comm_taskBind = jxbt_get_jfield(env, jtask_class_Comm, "taskBind", "J");
  50   jtask_field_Comm_receiving = jxbt_get_jfield(env, jtask_class_Comm, "receiving", "Z");
  51   xbt_assert(jtask_field_Task_bind && jtask_field_Comm_bind && jtask_field_Comm_taskBind &&
  52                  jtask_field_Comm_receiving && jtask_method_Comm_constructor,
  53              "Native initialization of msg/Task failed. Please report that bug");
  54 }
  55
  56 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_create(JNIEnv * env, jobject jtask, jstring jname,
  57                                       jdouble jflopsAmount, jdouble jbytesAmount)
  58 {
  59   const char *name = nullptr;      /* the name of the task                                 */
  60
  61   if (jname)
  62     name = env->GetStringUTFChars(jname, 0);
  63   msg_task_t task = MSG_task_create(name, static_cast<double>(jflopsAmount), static_cast<double>(jbytesAmount), jtask);
  64   if (jname)
  65     env->ReleaseStringUTFChars(jname, name);
  66
  67   /* bind & store the task */
  68   jtask_bind(jtask, task, env);
  69 }
  70
  71 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_parallelCreate(JNIEnv * env, jobject jtask, jstring jname,
  72                                          jobjectArray jhosts, jdoubleArray jcomputeDurations_arg,
  73                                          jdoubleArray jmessageSizes_arg)
  74 {
  75   int host_count = static_cast<int>(env->GetArrayLength(jhosts));
  76
  77   jdouble* jcomputeDurations = env->GetDoubleArrayElements(jcomputeDurations_arg, 0);
  78   msg_host_t* hosts          = new msg_host_t[host_count];
  79   double* computeDurations   = new double[host_count];
  80   for (int index = 0; index < host_count; index++) {
  81     jobject jhost           = env->GetObjectArrayElement(jhosts, index);
  82     hosts[index] = jhost_get_native(env, jhost);
  83     computeDurations[index] = jcomputeDurations[index];
  84   }
  85   env->ReleaseDoubleArrayElements(jcomputeDurations_arg, jcomputeDurations, 0);
  86
  87   jdouble* jmessageSizes = env->GetDoubleArrayElements(jmessageSizes_arg, 0);
  88   double* messageSizes   = new double[host_count * host_count];
  89   for (int index = 0; index < host_count * host_count; index++) {
  90     messageSizes[index] = jmessageSizes[index];
  91   }
  92   env->ReleaseDoubleArrayElements(jmessageSizes_arg, jmessageSizes, 0);
  93
  94   /* get the C string from the java string */
  95   const char* name = env->GetStringUTFChars(jname, 0);
  96   msg_task_t task  = MSG_parallel_task_create(name, host_count, hosts, computeDurations, messageSizes, jtask);
  97   env->ReleaseStringUTFChars(jname, name);
  98
  99   /* associate the java task object and the native task */
 100   jtask_bind(jtask, task, env);
 101
 102   delete[] hosts;
 103   delete[] computeDurations;
 104   delete[] messageSizes;
 105 }
 106
 107 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_cancel(JNIEnv * env, jobject jtask)
 108 {
 109   msg_task_t ptask = jtask_to_native(jtask, env);
 110
 111   if (not ptask) {
 112     jxbt_throw_notbound(env, "task", jtask);
 113     return;
 114   }
 115
 116   msg_error_t rv = MSG_task_cancel(ptask);
 117
 118   jxbt_check_res("MSG_task_cancel()", rv, MSG_OK, "unexpected error , please report this bug");
 119 }
 120
 121 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_execute(JNIEnv * env, jobject jtask)
 122 {
 123   msg_task_t task = jtask_to_native(jtask, env);
 124
 125   if (not task) {
 126     jxbt_throw_notbound(env, "task", jtask);
 127     return;
 128   }
 129   msg_error_t rv;
 130   try {
 131     rv = MSG_task_execute(task);
 132   } catch (simgrid::kernel::context::Context::StopRequest& e) {
 133     jxbt_throw_by_name(env, "org/simgrid/msg/ProcessKilledError", "Process killed");
 134   }
 135
 136   if (env->ExceptionOccurred())
 137     return;
 138   if (rv != MSG_OK) {
 139     jmsg_throw_status(env, rv);
 140   }
 141 }
 142
 143 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_setBound(JNIEnv * env, jobject jtask, jdouble bound)
 144 {
 145   msg_task_t task = jtask_to_native(jtask, env);
 146
 147   if (not task) {
 148     jxbt_throw_notbound(env, "task", jtask);
 149     return;
 150   }
 151   MSG_task_set_bound(task, bound);
 152 }
 153
 154 JNIEXPORT jstring JNICALL Java_org_simgrid_msg_Task_getName(JNIEnv * env, jobject jtask) {
 155   msg_task_t task = jtask_to_native(jtask, env);
 156
 157   if (not task) {
 158     jxbt_throw_notbound(env, "task", jtask);
 159     return nullptr;
 160   }
 161
 162   return env->NewStringUTF(MSG_task_get_name(task));
 163 }
 164
 165 JNIEXPORT jobject JNICALL Java_org_simgrid_msg_Task_getSender(JNIEnv * env, jobject jtask) {
 166   msg_process_t process;
 167
 168   msg_task_t task = jtask_to_native(jtask, env);
 169
 170   if (not task) {
 171     jxbt_throw_notbound(env, "task", jtask);
 172     return nullptr;
 173   }
 174
 175   process = MSG_task_get_sender(task);
 176   if (process == nullptr) {
 177     return nullptr;
 178   }
 179   return (jobject)jprocess_from_native(process);
 180 }
 181
 182 JNIEXPORT jobject JNICALL Java_org_simgrid_msg_Task_getSource(JNIEnv * env, jobject jtask)
 183 {
 184   msg_host_t host;
 185   msg_task_t task = jtask_to_native(jtask, env);
 186
 187   if (not task) {
 188     jxbt_throw_notbound(env, "task", jtask);
 189     return nullptr;
 190   }
 191
 192   host = MSG_task_get_source(task);
 193   if (host == nullptr) {
 194     return nullptr;
 195   }
 196   if (not host->extension(JAVA_HOST_LEVEL)) {
 197     jxbt_throw_jni(env, "MSG_task_get_source() failed");
 198     return nullptr;
 199   }
 200
 201   return (jobject) host->extension(JAVA_HOST_LEVEL);
 202 }
 203
 204 JNIEXPORT jdouble JNICALL Java_org_simgrid_msg_Task_getFlopsAmount(JNIEnv * env, jobject jtask)
 205 {
 206   msg_task_t ptask = jtask_to_native(jtask, env);
 207
 208   if (not ptask) {
 209     jxbt_throw_notbound(env, "task", jtask);
 210     return -1;
 211   }
 212   return (jdouble)MSG_task_get_flops_amount(ptask);
 213 }
 214
 215 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_setName(JNIEnv *env, jobject jtask, jobject jname) {
 216   msg_task_t task = jtask_to_native(jtask, env);
 217
 218   if (not task) {
 219     jxbt_throw_notbound(env, "task", jtask);
 220     return;
 221   }
 222   const char *name = env->GetStringUTFChars((jstring) jname, 0);
 223
 224   env->SetObjectField(jtask, jtask_field_Task_name, jname);
 225   MSG_task_set_name(task, name);
 226
 227   env->ReleaseStringUTFChars((jstring) jname, name);
 228 }
 229
 230 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_setPriority(JNIEnv * env, jobject jtask, jdouble priority)
 231 {
 232   msg_task_t task = jtask_to_native(jtask, env);
 233
 234   if (not task) {
 235     jxbt_throw_notbound(env, "task", jtask);
 236     return;
 237   }
 238   MSG_task_set_priority(task, static_cast<double>(priority));
 239 }
 240
 241 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_setFlopsAmount (JNIEnv *env, jobject jtask, jdouble computationAmount)
 242 {
 243   msg_task_t task = jtask_to_native(jtask, env);
 244
 245   if (not task) {
 246     jxbt_throw_notbound(env, "task", jtask);
 247     return;
 248   }
 249   MSG_task_set_flops_amount(task, static_cast<double>(computationAmount));
 250 }
 251
 252 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_setBytesAmount (JNIEnv *env, jobject jtask, jdouble dataSize)
 253 {
 254   msg_task_t task = jtask_to_native(jtask, env);
 255
 256   if (not task) {
 257     jxbt_throw_notbound(env, "task", jtask);
 258     return;
 259   }
 260   env->SetDoubleField(jtask, jtask_field_Task_messageSize, dataSize);
 261   MSG_task_set_bytes_amount(task, static_cast<double>(dataSize));
 262 }
 263
 264 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_sendBounded(JNIEnv * env,jobject jtask, jstring jalias,
 265                                                              jdouble jtimeout,jdouble maxrate)
 266 {
 267   msg_task_t task = jtask_to_native(jtask, env);
 268   if (not task) {
 269     jxbt_throw_notbound(env, "task", jtask);
 270     return;
 271   }
 272
 273   /* Add a global ref into the Ctask so that the receiver can use it */
 274   MSG_task_set_data(task, (void *) env->NewGlobalRef(jtask));
 275
 276   const char* alias = env->GetStringUTFChars(jalias, 0);
 277   msg_error_t res =
 278       MSG_task_send_with_timeout_bounded(task, alias, static_cast<double>(jtimeout), static_cast<double>(maxrate));
 279   env->ReleaseStringUTFChars(jalias, alias);
 280
 281   if (res != MSG_OK)
 282     jmsg_throw_status(env, res);
 283 }
 284
 285 JNIEXPORT jobject JNICALL Java_org_simgrid_msg_Task_receive(JNIEnv* env, jclass cls, jstring jalias, jdouble jtimeout)
 286 {
 287   msg_task_t task = nullptr;
 288
 289   const char *alias = env->GetStringUTFChars(jalias, 0);
 290   msg_error_t rv;
 291   try {
 292     rv = MSG_task_receive_ext(&task, alias, (double)jtimeout, /*host*/ nullptr);
 293   } catch (simgrid::kernel::context::Context::StopRequest& e) {
 294     jxbt_throw_by_name(env, "org/simgrid/msg/ProcessKilledError", "Process killed");
 295   }
 296   env->ReleaseStringUTFChars(jalias, alias);
 297   if (env->ExceptionOccurred())
 298     return nullptr;
 299   if (rv != MSG_OK) {
 300     jmsg_throw_status(env, rv);
 301     return nullptr;
 302   }
 303   jobject jtask_global = (jobject) MSG_task_get_data(task);
 304
 305   /* Convert the global ref into a local ref so that the JVM can free the stuff */
 306   jobject jtask_local = env->NewLocalRef(jtask_global);
 307   env->DeleteGlobalRef(jtask_global);
 308   MSG_task_set_data(task, nullptr);
 309
 310   return (jobject) jtask_local;
 311 }
 312
 313 JNIEXPORT jobject JNICALL Java_org_simgrid_msg_Task_irecv(JNIEnv * env, jclass cls, jstring jmailbox) {
 314   jclass comm_class = env->FindClass("org/simgrid/msg/Comm");
 315   if (not comm_class)
 316     return nullptr;
 317
 318   //pointer to store the task object pointer.
 319   msg_task_t* task = new msg_task_t(nullptr);
 320   /* There should be a cache here */
 321
 322   jobject jcomm = env->NewObject(comm_class, jtask_method_Comm_constructor);
 323   if (not jcomm) {
 324     jxbt_throw_jni(env, "Can't create a Comm object.");
 325     return nullptr;
 326   }
 327
 328   const char* mailbox = env->GetStringUTFChars(jmailbox, 0);
 329   msg_comm_t comm     = MSG_task_irecv(task, mailbox);
 330   env->ReleaseStringUTFChars(jmailbox, mailbox);
 331
 332   env->SetLongField(jcomm, jtask_field_Comm_bind, (jlong) (uintptr_t)(comm));
 333   env->SetLongField(jcomm, jtask_field_Comm_taskBind, (jlong) (uintptr_t)(task));
 334   env->SetBooleanField(jcomm, jtask_field_Comm_receiving, JNI_TRUE);
 335
 336   return jcomm;
 337 }
 338
 339 JNIEXPORT jobject JNICALL Java_org_simgrid_msg_Task_receiveBounded(JNIEnv* env, jclass cls, jstring jalias,
 340                                                                    jdouble jtimeout, jdouble rate)
 341 {
 342   msg_task_t task = nullptr;
 343
 344   const char *alias = env->GetStringUTFChars(jalias, 0);
 345   msg_error_t res   = MSG_task_receive_ext_bounded(&task, alias, static_cast<double>(jtimeout), /*host*/ nullptr,
 346                                                  static_cast<double>(rate));
 347   if (env->ExceptionOccurred())
 348     return nullptr;
 349   if (res != MSG_OK) {
 350     jmsg_throw_status(env, res);
 351     return nullptr;
 352   }
 353   jobject jtask_global = (jobject)MSG_task_get_data(task);
 354
 355   /* Convert the global ref into a local ref so that the JVM can free the stuff */
 356   jobject jtask_local = env->NewLocalRef(jtask_global);
 357   env->DeleteGlobalRef(jtask_global);
 358   MSG_task_set_data(task, nullptr);
 359
 360   env->ReleaseStringUTFChars(jalias, alias);
 361
 362   return (jobject) jtask_local;
 363 }
 364
 365 JNIEXPORT jobject JNICALL Java_org_simgrid_msg_Task_irecvBounded(JNIEnv * env, jclass cls, jstring jmailbox,
 366                                                                  jdouble rate)
 367 {
 368   jclass comm_class = env->FindClass("org/simgrid/msg/Comm");
 369   if (not comm_class)
 370     return nullptr;
 371
 372   // pointer to store the task object pointer.
 373   msg_task_t* task = new msg_task_t(nullptr);
 374
 375   jobject jcomm = env->NewObject(comm_class, jtask_method_Comm_constructor);
 376   if (not jcomm) {
 377     jxbt_throw_jni(env, "Can't create a Comm object.");
 378     return nullptr;
 379   }
 380
 381   const char* mailbox = env->GetStringUTFChars(jmailbox, 0);
 382   msg_comm_t comm     = MSG_task_irecv_bounded(task, mailbox, static_cast<double>(rate));
 383   env->ReleaseStringUTFChars(jmailbox, mailbox);
 384
 385   env->SetLongField(jcomm, jtask_field_Comm_bind, (jlong) (uintptr_t)(comm));
 386   env->SetLongField(jcomm, jtask_field_Comm_taskBind, (jlong) (uintptr_t)(task));
 387   env->SetBooleanField(jcomm, jtask_field_Comm_receiving, JNI_TRUE);
 388
 389   return jcomm;
 390 }
 391
 392 JNIEXPORT jobject JNICALL Java_org_simgrid_msg_Task_isend(JNIEnv *env, jobject jtask, jstring jmailbox)
 393 {
 394   msg_comm_t comm;
 395
 396   jclass comm_class = env->FindClass("org/simgrid/msg/Comm");
 397
 398   if (not comm_class)
 399     return nullptr;
 400
 401   jobject jcomm       = env->NewObject(comm_class, jtask_method_Comm_constructor);
 402   const char* mailbox = env->GetStringUTFChars(jmailbox, 0);
 403
 404   msg_task_t task = jtask_to_native(jtask, env);
 405
 406   if (not task) {
 407     env->ReleaseStringUTFChars(jmailbox, mailbox);
 408     env->DeleteLocalRef(jcomm);
 409     jxbt_throw_notbound(env, "task", jtask);
 410         return nullptr;
 411   }
 412
 413   MSG_task_set_data(task, (void *) env->NewGlobalRef(jtask));
 414   comm = MSG_task_isend(task,mailbox);
 415
 416   env->SetLongField(jcomm, jtask_field_Comm_bind, (jlong) (uintptr_t)(comm));
 417   env->SetLongField(jcomm, jtask_field_Comm_taskBind, (jlong) (uintptr_t)(nullptr));
 418   env->SetBooleanField(jcomm, jtask_field_Comm_receiving, JNI_FALSE);
 419
 420   env->ReleaseStringUTFChars(jmailbox, mailbox);
 421
 422   return jcomm;
 423 }
 424
 425 JNIEXPORT jobject JNICALL Java_org_simgrid_msg_Task_isendBounded(JNIEnv *env, jobject jtask, jstring jmailbox,
 426                                                                  jdouble maxrate)
 427 {
 428   msg_task_t task;
 429   jobject jcomm;
 430   msg_comm_t comm;
 431   const char *mailbox;
 432
 433   jclass comm_class = env->FindClass("org/simgrid/msg/Comm");
 434   if (not comm_class)
 435     return nullptr;
 436
 437   jcomm = env->NewObject(comm_class, jtask_method_Comm_constructor);
 438   mailbox = env->GetStringUTFChars(jmailbox, 0);
 439
 440   task = jtask_to_native(jtask, env);
 441
 442   if (not task) {
 443     env->ReleaseStringUTFChars(jmailbox, mailbox);
 444     env->DeleteLocalRef(jcomm);
 445     jxbt_throw_notbound(env, "task", jtask);
 446         return nullptr;
 447   }
 448
 449   MSG_task_set_data(task, (void *) env->NewGlobalRef(jtask));
 450   comm = MSG_task_isend_bounded(task,mailbox,maxrate);
 451
 452   env->SetLongField(jcomm, jtask_field_Comm_bind, (jlong) (uintptr_t)(comm));
 453   env->SetLongField(jcomm, jtask_field_Comm_taskBind, (jlong) (uintptr_t)(nullptr));
 454   env->SetBooleanField(jcomm, jtask_field_Comm_receiving, JNI_FALSE);
 455
 456   env->ReleaseStringUTFChars(jmailbox, mailbox);
 457
 458   return jcomm;
 459 }
 460
 461 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_nativeFinalize(JNIEnv * env, jobject jtask)
 462 {
 463   msg_task_t task = jtask_to_native(jtask, env);
 464
 465   if (not task) {
 466     jxbt_throw_notbound(env, "task", jtask);
 467     return;
 468     }
 469
 470     MSG_task_destroy(task);
 471 }
 472
 473 static void msg_task_cancel_on_failed_dsend(void*t) {
 474   msg_task_t task = (msg_task_t) t;
 475   JNIEnv *env =get_current_thread_env();
 476   jobject jtask_global = (jobject) MSG_task_get_data(task);
 477
 478   /* Destroy the global ref so that the JVM can free the stuff */
 479   env->DeleteGlobalRef(jtask_global);
 480   MSG_task_set_data(task, nullptr);
 481   MSG_task_destroy(task);
 482 }
 483
 484 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_dsend(JNIEnv * env, jobject jtask, jstring jalias)
 485 {
 486   const char *alias = env->GetStringUTFChars(jalias, 0);
 487
 488   msg_task_t task = jtask_to_native(jtask, env);
 489
 490   if (not task) {
 491     env->ReleaseStringUTFChars(jalias, alias);
 492     jxbt_throw_notbound(env, "task", jtask);
 493     return;
 494   }
 495
 496   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
 497   MSG_task_set_data(task, (void *) env->NewGlobalRef(jtask));
 498   MSG_task_dsend(task, alias, msg_task_cancel_on_failed_dsend);
 499
 500   env->ReleaseStringUTFChars(jalias, alias);
 501 }
 502
 503 JNIEXPORT void JNICALL Java_org_simgrid_msg_Task_dsendBounded(JNIEnv * env, jobject jtask, jstring jalias,
 504                                                               jdouble maxrate)
 505 {
 506   const char *alias = env->GetStringUTFChars(jalias, 0);
 507
 508   msg_task_t task = jtask_to_native(jtask, env);
 509
 510   if (not task) {
 511     env->ReleaseStringUTFChars(jalias, alias);
 512     jxbt_throw_notbound(env, "task", jtask);
 513     return;
 514   }
 515
 516   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
 517   MSG_task_set_data(task, (void *) env->NewGlobalRef(jtask));
 518   MSG_task_dsend_bounded(task, alias, msg_task_cancel_on_failed_dsend,static_cast<double>(maxrate));
 519
 520   env->ReleaseStringUTFChars(jalias, alias);
 521 }
 522
 523 JNIEXPORT jboolean JNICALL Java_org_simgrid_msg_Task_listen(JNIEnv * env, jclass cls, jstring jalias)
 524 {
 525   const char *alias = env->GetStringUTFChars(jalias, 0);
 526   int rv = MSG_task_listen(alias);
 527   env->ReleaseStringUTFChars(jalias, alias);
 528
 529   return (jboolean) rv;
 530 }
 531
 532 JNIEXPORT jint JNICALL Java_org_simgrid_msg_Task_listenFrom(JNIEnv * env, jclass cls, jstring jalias)
 533 {
 534   const char *alias = env->GetStringUTFChars(jalias, 0);
 535   int rv = MSG_task_listen_from(alias);
 536   env->ReleaseStringUTFChars(jalias, alias);
 537
 538   return (jint) rv;
 539 }