X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/96f4bbf2c38ff9e20c2eb379f95879a1bc41a1d2..514c85494408cbf2eab157d78843a5db586a57c0:/src/jmsg_task.c

diff --git a/src/jmsg_task.c b/src/jmsg_task.c
index 20c560e8a1..8b52a30806 100644
--- a/src/jmsg_task.c
+++ b/src/jmsg_task.c
@@ -7,15 +7,22 @@
   * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #include "jmsg.h"
+
+#include "smx_context_java.h"
+
+#include "jmsg_host.h"
 #include "jmsg_task.h"
+
 #include "jxbt_utilities.h"
 
 #include <msg/msg.h>
+
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
 
-static jmethodID jtask_field_Comm_constructor;
+static jmethodID jtask_method_Comm_constructor;
 
 static jfieldID jtask_field_Task_bind;
+static jfieldID jtask_field_Task_name;
 static jfieldID jtask_field_Comm_bind;
 static jfieldID jtask_field_Comm_taskBind;
 static jfieldID jtask_field_Comm_receiving;
@@ -38,14 +45,407 @@ jboolean jtask_is_valid(jobject jtask, JNIEnv * env)
 JNIEXPORT void JNICALL
 Java_org_simgrid_msg_Task_nativeInit(JNIEnv *env, jclass cls) {
 	jclass jtask_class_Comm = (*env)->FindClass(env, "org/simgrid/msg/Comm");
+	jclass jtask_class_Task = (*env)->FindClass(env, "org/simgrid/msg/Task");
 
-	jtask_field_Comm_constructor = (*env)->GetMethodID(env, jtask_class_Comm, "<init>", "()V");
-	//FIXME: Don't use jxbt_get_sfield directly.
+	jtask_method_Comm_constructor = (*env)->GetMethodID(env, jtask_class_Comm, "<init>", "()V");
+	//FIXME: Don't use jxbt_get_sfield directly, it is slower.
 	jtask_field_Task_bind = jxbt_get_sfield(env, "org/simgrid/msg/Task", "bind", "J");
+	jtask_field_Task_name = jxbt_get_jfield(env, jtask_class_Task, "name", "Ljava/lang/String;");
 	jtask_field_Comm_bind = jxbt_get_sfield(env, "org/simgrid/msg/Comm", "bind", "J");
 	jtask_field_Comm_taskBind = jxbt_get_sfield(env, "org/simgrid/msg/Comm", "taskBind", "J");
 	jtask_field_Comm_receiving = jxbt_get_sfield(env, "org/simgrid/msg/Comm", "receiving", "Z");
+	if (!jtask_field_Task_bind || !jtask_class_Task || !jtask_field_Comm_bind || !jtask_field_Comm_taskBind ||
+		  !jtask_field_Comm_receiving || !jtask_method_Comm_constructor) {
+		  	jxbt_throw_native(env,bprintf("Can't find some fields in Java class."));
+		  }
+}
+
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Task_create(JNIEnv * env,
+                                      jobject jtask, jstring jname,
+                                      jdouble jcomputeDuration,
+                                      jdouble jmessageSize)
+{
+  m_task_t task;                /* the native task to create                            */
+  const char *name = NULL;      /* the name of the task                                 */
+
+  if (jcomputeDuration < 0) {
+    jxbt_throw_illegal(env,
+                       bprintf
+                       ("Task ComputeDuration (%f) cannot be negative",
+                        (double) jcomputeDuration));
+    return;
+  }
+
+  if (jmessageSize < 0) {
+    jxbt_throw_illegal(env,
+                       bprintf("Task MessageSize (%f) cannot be negative",
+                               (double) jmessageSize));
+    return;
+  }
+
+  if (jname) {
+    /* get the C string from the java string */
+    name = (*env)->GetStringUTFChars(env, jname, 0);
+  }
+
+
+  /* create the task */
+  task =
+      MSG_task_create(name, (double) jcomputeDuration,
+                      (double) jmessageSize, NULL);
+  if (jname)
+    (*env)->ReleaseStringUTFChars(env, jname, name);
+  /* sets the task name */
+  (*env)->SetObjectField(env, jtask, jtask_field_Task_name, jname);
+  /* bind & store the task */
+  jtask_bind(jtask, task, env);
+  MSG_task_set_data(task, jtask);
+}
+
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Task_parallelCreate(JNIEnv * env,
+                                               jobject jtask,
+                                               jstring jname,
+                                               jobjectArray jhosts,
+                                               jdoubleArray
+                                               jcomputeDurations_arg,
+                                               jdoubleArray
+                                               jmessageSizes_arg) {
+
+  m_task_t task;                /* the native parallel task to create           */
+  const char *name;             /* the name of the task                         */
+  int host_count;
+  m_host_t *hosts;
+  double *computeDurations;
+  double *messageSizes;
+  jdouble *jcomputeDurations;
+  jdouble *jmessageSizes;
+
+  jobject jhost;
+  int index;
+
+
+  if (!jcomputeDurations_arg) {
+    jxbt_throw_null(env,
+                    xbt_strdup
+                    ("Parallel task compute durations cannot be null"));
+    return;
+  }
+
+  if (!jmessageSizes_arg) {
+    jxbt_throw_null(env,
+                    xbt_strdup
+                    ("Parallel task message sizes cannot be null"));
+    return;
+  }
+
+  if (!jname) {
+    jxbt_throw_null(env, xbt_strdup("Parallel task name cannot be null"));
+    return;
+  }
+
+  host_count = (int) (*env)->GetArrayLength(env, jhosts);
+
+
+  hosts = xbt_new0(m_host_t, host_count);
+  computeDurations = xbt_new0(double, host_count);
+  messageSizes = xbt_new0(double, host_count * host_count);
+
+  jcomputeDurations =
+      (*env)->GetDoubleArrayElements(env, jcomputeDurations_arg, 0);
+  jmessageSizes =
+      (*env)->GetDoubleArrayElements(env, jmessageSizes_arg, 0);
+
+  for (index = 0; index < host_count; index++) {
+    jhost = (*env)->GetObjectArrayElement(env, jhosts, index);
+    hosts[index] = jhost_get_native(env, jhost);
+    computeDurations[index] = jcomputeDurations[index];
+  }
+  for (index = 0; index < host_count * host_count; index++) {
+    messageSizes[index] = jmessageSizes[index];
+  }
+
+  (*env)->ReleaseDoubleArrayElements(env, jcomputeDurations_arg,
+                                     jcomputeDurations, 0);
+  (*env)->ReleaseDoubleArrayElements(env, jmessageSizes_arg, jmessageSizes,
+                                     0);
+
+
+  /* get the C string from the java string */
+  name = (*env)->GetStringUTFChars(env, jname, 0);
+
+  task =
+      MSG_parallel_task_create(name, host_count, hosts, computeDurations,
+                               messageSizes, NULL);
+
+  (*env)->ReleaseStringUTFChars(env, jname, name);
+  /* sets the task name */
+  (*env)->SetObjectField(env, jtask, jtask_field_Task_name, jname);
+  /* associate the java task object and the native task */
+  jtask_bind(jtask, task, env);
+
+  MSG_task_set_data(task, (void *) jtask);
+
+  if (!MSG_task_get_data(task))
+    jxbt_throw_jni(env, "global ref allocation failed");
+}
+
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Task_cancel(JNIEnv * env,
+                                      jobject jtask)
+{
+  m_task_t ptask = jtask_to_native_task(jtask, env);
+
+  if (!ptask) {
+    jxbt_throw_notbound(env, "task", jtask);
+    return;
+  }
+
+  MSG_error_t rv = MSG_task_cancel(ptask);
+
+  jxbt_check_res("MSG_task_cancel()", rv, MSG_OK,
+                 bprintf("unexpected error , please report this bug"));
+}
+
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Task_execute(JNIEnv * env,
+                                       jobject jtask)
+{
+  m_task_t task = jtask_to_native_task(jtask, env);
+
+  if (!task) {
+    jxbt_throw_notbound(env, "task", jtask);
+    return;
+  }
+
+  MSG_error_t rv = MSG_task_execute(task);
+
+  jxbt_check_res("MSG_task_execute()", rv,
+                 MSG_HOST_FAILURE | MSG_TASK_CANCELED,
+                 bprintf("while executing task %s",
+                         MSG_task_get_name(task)));
+}
+
+JNIEXPORT jstring JNICALL
+Java_org_simgrid_msg_Task_getName(JNIEnv * env,
+                                       jobject jtask) {
+  m_task_t task = jtask_to_native_task(jtask, env);
+
+  if (!task) {
+    jxbt_throw_notbound(env, "task", jtask);
+    return NULL;
+  }
+
+  return (*env)->NewStringUTF(env, MSG_task_get_name(task));
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_simgrid_msg_Task_getSender(JNIEnv * env,
+                                         jobject jtask) {
+  m_process_t process;
+
+  m_task_t task = jtask_to_native_task(jtask, env);
+
+  if (!task) {
+    jxbt_throw_notbound(env, "task", jtask);
+    return NULL;
+  }
+
+  process = MSG_task_get_sender(task);
+  if (process == NULL) {
+  	return NULL;
+  }
+  return (jobject) native_to_java_process(process);
+}
+
+JNIEXPORT jobject JNICALL
+Java_org_simgrid_msg_Task_getSource(JNIEnv * env,
+                                         jobject jtask)
+{
+  m_host_t host;
+  m_task_t task = jtask_to_native_task(jtask, env);
+
+  if (!task) {
+    jxbt_throw_notbound(env, "task", jtask);
+    return NULL;
+  }
+
+  host = MSG_task_get_source(task);
+  if (host == NULL) {
+  	return NULL;
+  }
+  if (!MSG_host_get_data(host)) {
+    jxbt_throw_jni(env, "MSG_task_get_source() failed");
+    return NULL;
+  }
+
+  return (jobject) MSG_host_get_data(host);
+}
+
+JNIEXPORT jdouble JNICALL
+Java_org_simgrid_msg_Task_getComputeDuration(JNIEnv * env,
+                                                  jobject jtask)
+{
+  m_task_t ptask = jtask_to_native_task(jtask, env);
+
+  if (!ptask) {
+    jxbt_throw_notbound(env, "task", jtask);
+    return -1;
+  }
+  return (jdouble) MSG_task_get_compute_duration(ptask);
+}
+
+JNIEXPORT jdouble JNICALL
+Java_org_simgrid_msg_Task_getRemainingDuration(JNIEnv * env, jobject jtask)
+{
+  m_task_t ptask = jtask_to_native_task(jtask, env);
+
+  if (!ptask) {
+    jxbt_throw_notbound(env, "task", jtask);
+    return -1;
+  }
+  return (jdouble) MSG_task_get_remaining_computation(ptask);
+}
+
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Task_setPriority(JNIEnv * env,
+                                           jobject jtask, jdouble priority)
+{
+  m_task_t task = jtask_to_native_task(jtask, env);
+
+  if (!task) {
+    jxbt_throw_notbound(env, "task", jtask);
+    return;
+  }
+  MSG_task_set_priority(task, (double) priority);
+}
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Task_setComputeDuration
+		(JNIEnv *env, jobject jtask, jdouble computationAmount) {
+	m_task_t task = jtask_to_native_task(jtask, env);
+
+	if (!task) {
+    jxbt_throw_notbound(env, "task", jtask);
+    return;
+	}
+	MSG_task_set_compute_duration(task, (double) computationAmount);
 }
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Task_send(JNIEnv * env,jobject jtask,
+                                    jstring jalias,
+                                    jdouble jtimeout)
+{
+  MSG_error_t rv;
+  const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+  m_task_t task = jtask_to_native_task(jtask, env);
+
+
+  if (!task) {
+    (*env)->ReleaseStringUTFChars(env, jalias, alias);
+    jxbt_throw_notbound(env, "task", jtask);
+    return;
+  }
+
+  /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
+  MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
+  rv = MSG_task_send_with_timeout(task, alias, (double) jtimeout);
+
+  (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+  jxbt_check_res("MSG_task_send_with_timeout()", rv,
+                 MSG_HOST_FAILURE | MSG_TRANSFER_FAILURE | MSG_TIMEOUT,
+                 bprintf("while sending task %s to mailbox %s",
+                         MSG_task_get_name(task), alias));
+}
+
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Task_sendBounded(JNIEnv * env, jobject jtask,
+                                           jstring jalias,
+                                           jdouble jmaxRate)
+{
+  m_task_t task = jtask_to_native_task(jtask, env);
+  MSG_error_t rv;
+  const char *alias;
+
+  if (!task) {
+    jxbt_throw_notbound(env, "task", jtask);
+    return;
+  }
+
+  alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+  /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
+  MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
+  rv = MSG_task_send_bounded(task, alias, (double) jmaxRate);
+
+  (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+  jxbt_check_res("MSG_task_send_bounded()", rv,
+                 MSG_HOST_FAILURE | MSG_TRANSFER_FAILURE | MSG_TIMEOUT,
+                 bprintf
+                 ("while sending task %s to mailbox %s with max rate %f",
+                  MSG_task_get_name(task), alias, (double) jmaxRate));
+
+}
+
+
+JNIEXPORT jobject JNICALL
+Java_org_simgrid_msg_Task_receive(JNIEnv * env, jclass cls,
+                                       jstring jalias, jdouble jtimeout,
+                                       jobject jhost)
+{
+  MSG_error_t rv;
+  m_task_t task = NULL;
+  m_host_t host = NULL;
+  jobject jtask_global, jtask_local;
+  const char *alias;
+
+  if (jhost) {
+    host = jhost_get_native(env, jhost);
+
+    if (!host) {
+      jxbt_throw_notbound(env, "host", jhost);
+      return NULL;
+    }
+  }
+
+  alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+  rv = MSG_task_receive_ext(&task, alias, (double) jtimeout, host);
+  if (rv != MSG_OK) {
+  	switch (rv) {
+  		case MSG_TIMEOUT:
+  			jxbt_throw_time_out_failure(env,NULL);
+  		break;
+  		case MSG_TRANSFER_FAILURE:
+  			jxbt_throw_transfer_failure(env,NULL);
+  		break;
+  		case MSG_HOST_FAILURE:
+  			jxbt_throw_host_failure(env,NULL);
+  		break;
+  		default:
+  			jxbt_throw_native(env,bprintf("receive failed"));
+  	}
+  	return NULL;
+  }
+  jtask_global = MSG_task_get_data(task);
+
+  /* Convert the global ref into a local ref so that the JVM can free the stuff */
+  jtask_local = (*env)->NewLocalRef(env, jtask_global);
+  (*env)->DeleteGlobalRef(env, jtask_global);
+  MSG_task_set_data(task, NULL);
+
+  (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+  jxbt_check_res("MSG_task_receive_ext()", rv,
+                 MSG_HOST_FAILURE | MSG_TRANSFER_FAILURE | MSG_TIMEOUT,
+                 bprintf("while receiving from mailbox %s", alias));
+
+  return (jobject) jtask_local;
+}
+
 
 JNIEXPORT jobject JNICALL
 Java_org_simgrid_msg_Task_irecv(JNIEnv * env, jclass cls, jstring jmailbox) {
@@ -63,7 +463,7 @@ Java_org_simgrid_msg_Task_irecv(JNIEnv * env, jclass cls, jstring jmailbox) {
 		return NULL;
 	}
 
-	jobject jcomm = (*env)->NewObject(env, comm_class, jtask_field_Comm_constructor);
+	jobject jcomm = (*env)->NewObject(env, comm_class, jtask_method_Comm_constructor);
 	if (!jcomm) {
 		jxbt_throw_native(env,bprintf("Can't create a Comm object."));
 		return NULL;
@@ -97,7 +497,7 @@ Java_org_simgrid_msg_Task_isend(JNIEnv *env, jobject jtask, jstring jmailbox) {
 
 	if (!comm_class) return NULL;
 
-	jcomm = (*env)->NewObject(env, comm_class, jtask_field_Comm_constructor);
+	jcomm = (*env)->NewObject(env, comm_class, jtask_method_Comm_constructor);
 	mailbox = (*env)->GetStringUTFChars(env, jmailbox, 0);
 
 	task = jtask_to_native_task(jtask, env);
@@ -120,3 +520,89 @@ Java_org_simgrid_msg_Task_isend(JNIEnv *env, jobject jtask, jstring jmailbox) {
 
 	return jcomm;
 }
+
+static void msg_task_cancel_on_failed_dsend(void*t) {
+	m_task_t task = t;
+	JNIEnv *env =get_current_thread_env();
+	jobject jtask_global = MSG_task_get_data(task);
+
+	/* Destroy the global ref so that the JVM can free the stuff */
+	(*env)->DeleteGlobalRef(env, jtask_global);
+	MSG_task_set_data(task, NULL);
+	MSG_task_destroy(task);
+}
+
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Task_dsend(JNIEnv * env, jobject jtask,
+                                jstring jalias) {
+
+  const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+  m_task_t task = jtask_to_native_task(jtask, env);
+
+
+  if (!task) {
+    (*env)->ReleaseStringUTFChars(env, jalias, alias);
+    jxbt_throw_notbound(env, "task", jtask);
+    return;
+  }
+
+  /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
+  MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
+  MSG_task_dsend(task, alias, msg_task_cancel_on_failed_dsend);
+
+  (*env)->ReleaseStringUTFChars(env, jalias, alias);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_org_simgrid_msg_Task_listen(JNIEnv * env, jclass cls,
+    													   jstring jalias) {
+
+  const char *alias;
+  int rv;
+
+  alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+  rv = MSG_task_listen(alias);
+
+  (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+  return (jboolean) rv;
+}
+
+JNIEXPORT jint JNICALL
+Java_org_simgrid_msg_Task_listenFromHost(JNIEnv * env, jclass cls,
+    																	   jstring jalias,
+    																	   jobject jhost) {
+  int rv;
+  const char *alias;
+
+  m_host_t host = jhost_get_native(env, jhost);
+
+  if (!host) {
+    jxbt_throw_notbound(env, "host", jhost);
+    return -1;
+  }
+  alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+  rv = MSG_task_listen_from_host(alias, host);
+
+  (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+  return (jint) rv;
+}
+
+
+JNIEXPORT jint JNICALL
+Java_org_simgrid_msg_Task_listenFrom(JNIEnv * env, jclass cls,
+                                          		jstring jalias) {
+
+  int rv;
+  const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+  rv = MSG_task_listen_from(alias);
+
+  (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+  return (jint) rv;
+}