Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
844ed84f8cf1c943e892c1287d69d8de9f95a4aa
[simgrid.git] / 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 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_Comm_bind;
26 static jfieldID jtask_field_Comm_taskBind;
27 static jfieldID jtask_field_Comm_receiving;
28
29 void jtask_bind(jobject jtask, m_task_t task, JNIEnv * env)
30 {
31   (*env)->SetLongField(env, jtask, jtask_field_Task_bind, (jlong) (long) (task));
32 }
33
34 m_task_t jtask_to_native_task(jobject jtask, JNIEnv * env)
35 {
36   return (m_task_t) (long) (*env)->GetLongField(env, jtask, jtask_field_Task_bind);
37 }
38
39 jboolean jtask_is_valid(jobject jtask, JNIEnv * env)
40 {
41   return (*env)->GetLongField(env, jtask, jtask_field_Task_bind) ? JNI_TRUE : JNI_FALSE;
42 }
43
44 JNIEXPORT void JNICALL
45 Java_org_simgrid_msg_Task_nativeInit(JNIEnv *env, jclass cls) {
46         jclass jtask_class_Comm = (*env)->FindClass(env, "org/simgrid/msg/Comm");
47         jclass jtask_class_Task = (*env)->FindClass(env, "org/simgrid/msg/Task");
48
49         jtask_method_Comm_constructor = (*env)->GetMethodID(env, jtask_class_Comm, "<init>", "()V");
50         //FIXME: Don't use jxbt_get_sfield directly, it is slower.
51         jtask_field_Task_bind = jxbt_get_sfield(env, "org/simgrid/msg/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_sfield(env, "org/simgrid/msg/Comm", "bind", "J");
54         jtask_field_Comm_taskBind = jxbt_get_sfield(env, "org/simgrid/msg/Comm", "taskBind", "J");
55         jtask_field_Comm_receiving = jxbt_get_sfield(env, "org/simgrid/msg/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
310 JNIEXPORT void JNICALL
311 Java_org_simgrid_msg_Task_setPriority(JNIEnv * env,
312                                            jobject jtask, jdouble priority)
313 {
314   m_task_t task = jtask_to_native_task(jtask, env);
315
316   if (!task) {
317     jxbt_throw_notbound(env, "task", jtask);
318     return;
319   }
320   MSG_task_set_priority(task, (double) priority);
321 }
322 JNIEXPORT void JNICALL
323 Java_org_simgrid_msg_Task_send(JNIEnv * env,jobject jtask,
324                                     jstring jalias,
325                                     jdouble jtimeout)
326 {
327   MSG_error_t rv;
328   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
329
330   m_task_t task = jtask_to_native_task(jtask, env);
331
332
333   if (!task) {
334     (*env)->ReleaseStringUTFChars(env, jalias, alias);
335     jxbt_throw_notbound(env, "task", jtask);
336     return;
337   }
338
339   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
340   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
341   rv = MSG_task_send_with_timeout(task, alias, (double) jtimeout);
342
343   (*env)->ReleaseStringUTFChars(env, jalias, alias);
344
345   jxbt_check_res("MSG_task_send_with_timeout()", rv,
346                  MSG_HOST_FAILURE | MSG_TRANSFER_FAILURE | MSG_TIMEOUT,
347                  bprintf("while sending task %s to mailbox %s",
348                          MSG_task_get_name(task), alias));
349 }
350
351 JNIEXPORT void JNICALL
352 Java_org_simgrid_msg_Task_sendBounded(JNIEnv * env, jobject jtask,
353                                            jstring jalias,
354                                            jdouble jmaxRate)
355 {
356   m_task_t task = jtask_to_native_task(jtask, env);
357   MSG_error_t rv;
358   const char *alias;
359
360   if (!task) {
361     jxbt_throw_notbound(env, "task", jtask);
362     return;
363   }
364
365   alias = (*env)->GetStringUTFChars(env, jalias, 0);
366
367   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
368   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
369   rv = MSG_task_send_bounded(task, alias, (double) jmaxRate);
370
371   (*env)->ReleaseStringUTFChars(env, jalias, alias);
372
373   jxbt_check_res("MSG_task_send_bounded()", rv,
374                  MSG_HOST_FAILURE | MSG_TRANSFER_FAILURE | MSG_TIMEOUT,
375                  bprintf
376                  ("while sending task %s to mailbox %s with max rate %f",
377                   MSG_task_get_name(task), alias, (double) jmaxRate));
378
379 }
380
381
382 JNIEXPORT jobject JNICALL
383 Java_org_simgrid_msg_Task_receive(JNIEnv * env, jclass cls,
384                                        jstring jalias, jdouble jtimeout,
385                                        jobject jhost)
386 {
387   MSG_error_t rv;
388   m_task_t task = NULL;
389   m_host_t host = NULL;
390   jobject jtask_global, jtask_local;
391   const char *alias;
392
393   if (jhost) {
394     host = jhost_get_native(env, jhost);
395
396     if (!host) {
397       jxbt_throw_notbound(env, "host", jhost);
398       return NULL;
399     }
400   }
401
402   alias = (*env)->GetStringUTFChars(env, jalias, 0);
403
404   rv = MSG_task_receive_ext(&task, alias, (double) jtimeout, host);
405   if (rv != MSG_OK) {
406         switch (rv) {
407                 case MSG_TIMEOUT:
408                         jxbt_throw_time_out_failure(env,NULL);
409                 break;
410                 case MSG_TRANSFER_FAILURE:
411                         jxbt_throw_transfer_failure(env,NULL);
412                 break;
413                 case MSG_HOST_FAILURE:
414                         jxbt_throw_host_failure(env,NULL);
415                 break;
416                 default:
417                         jxbt_throw_native(env,bprintf("receive failed"));
418         }
419         return NULL;
420   }
421   jtask_global = MSG_task_get_data(task);
422
423   /* Convert the global ref into a local ref so that the JVM can free the stuff */
424   jtask_local = (*env)->NewLocalRef(env, jtask_global);
425   (*env)->DeleteGlobalRef(env, jtask_global);
426   MSG_task_set_data(task, NULL);
427
428   (*env)->ReleaseStringUTFChars(env, jalias, alias);
429
430   jxbt_check_res("MSG_task_receive_ext()", rv,
431                  MSG_HOST_FAILURE | MSG_TRANSFER_FAILURE | MSG_TIMEOUT,
432                  bprintf("while receiving from mailbox %s", alias));
433
434   return (jobject) jtask_local;
435 }
436
437
438 JNIEXPORT jobject JNICALL
439 Java_org_simgrid_msg_Task_irecv(JNIEnv * env, jclass cls, jstring jmailbox) {
440         msg_comm_t comm;
441         const char *mailbox;
442         jclass comm_class;
443         //pointer to store the task object pointer.
444         m_task_t *task = xbt_new(m_task_t,1);
445         *task = NULL;
446         /* There should be a cache here */
447         comm_class = (*env)->FindClass(env, "org/simgrid/msg/Comm");
448
449         if (!comm_class) {
450                 jxbt_throw_native(env,bprintf("fieldID or methodID or class not found."));
451                 return NULL;
452         }
453
454         jobject jcomm = (*env)->NewObject(env, comm_class, jtask_method_Comm_constructor);
455         if (!jcomm) {
456                 jxbt_throw_native(env,bprintf("Can't create a Comm object."));
457                 return NULL;
458         }
459
460         mailbox = (*env)->GetStringUTFChars(env, jmailbox, 0);
461
462         comm = MSG_task_irecv(task,mailbox);
463
464         (*env)->SetLongField(env, jcomm, jtask_field_Comm_bind, (jlong) (long)(comm));
465         (*env)->SetLongField(env, jcomm, jtask_field_Comm_taskBind, (jlong) (long)(task));
466         (*env)->SetBooleanField(env, jcomm, jtask_field_Comm_receiving, JNI_TRUE);
467
468         (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
469
470         return jcomm;
471 }
472
473 JNIEXPORT jobject JNICALL
474 Java_org_simgrid_msg_Task_isend(JNIEnv *env, jobject jtask, jstring jmailbox) {
475         jclass comm_class;
476
477         const char *mailbox;
478
479         m_task_t task;
480
481         jobject jcomm;
482         msg_comm_t comm;
483
484         comm_class = (*env)->FindClass(env, "org/simgrid/msg/Comm");
485
486         if (!comm_class) return NULL;
487
488         jcomm = (*env)->NewObject(env, comm_class, jtask_method_Comm_constructor);
489         mailbox = (*env)->GetStringUTFChars(env, jmailbox, 0);
490
491         task = jtask_to_native_task(jtask, env);
492
493         if (!task) {
494     (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
495     (*env)->DeleteLocalRef(env, jcomm);
496     jxbt_throw_notbound(env, "task", jtask);
497                 return NULL;
498         }
499
500   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
501         comm = MSG_task_isend(task,mailbox);
502
503         (*env)->SetLongField(env, jcomm, jtask_field_Comm_bind, (jlong) (long)(comm));
504         (*env)->SetLongField(env, jcomm, jtask_field_Comm_taskBind, (jlong) (long)(NULL));
505         (*env)->SetBooleanField(env, jcomm, jtask_field_Comm_receiving, JNI_FALSE);
506
507         (*env)->ReleaseStringUTFChars(env, jmailbox, mailbox);
508
509         return jcomm;
510 }
511
512 static void msg_task_cancel_on_failed_dsend(void*t) {
513         m_task_t task = t;
514         JNIEnv *env =get_current_thread_env();
515         jobject jtask_global = MSG_task_get_data(task);
516
517         /* Destroy the global ref so that the JVM can free the stuff */
518         (*env)->DeleteGlobalRef(env, jtask_global);
519         MSG_task_set_data(task, NULL);
520         MSG_task_destroy(task);
521 }
522
523 JNIEXPORT void JNICALL
524 Java_org_simgrid_msg_Task_dsend(JNIEnv * env, jobject jtask,
525                                 jstring jalias) {
526
527   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
528
529   m_task_t task = jtask_to_native_task(jtask, env);
530
531
532   if (!task) {
533     (*env)->ReleaseStringUTFChars(env, jalias, alias);
534     jxbt_throw_notbound(env, "task", jtask);
535     return;
536   }
537
538   /* Pass a global ref to the Jtask into the Ctask so that the receiver can use it */
539   MSG_task_set_data(task, (void *) (*env)->NewGlobalRef(env, jtask));
540   MSG_task_dsend(task, alias, msg_task_cancel_on_failed_dsend);
541
542   (*env)->ReleaseStringUTFChars(env, jalias, alias);
543 }
544
545 JNIEXPORT jboolean JNICALL
546 Java_org_simgrid_msg_Task_listen(JNIEnv * env, jclass cls,
547                                                                                                            jstring jalias) {
548
549   const char *alias;
550   int rv;
551
552   alias = (*env)->GetStringUTFChars(env, jalias, 0);
553
554   rv = MSG_task_listen(alias);
555
556   (*env)->ReleaseStringUTFChars(env, jalias, alias);
557
558   return (jboolean) rv;
559 }
560
561 JNIEXPORT jint JNICALL
562 Java_org_simgrid_msg_Task_listenFromHost(JNIEnv * env, jclass cls,
563                                                                                                                                            jstring jalias,
564                                                                                                                                            jobject jhost) {
565   int rv;
566   const char *alias;
567
568   m_host_t host = jhost_get_native(env, jhost);
569
570   if (!host) {
571     jxbt_throw_notbound(env, "host", jhost);
572     return -1;
573   }
574   alias = (*env)->GetStringUTFChars(env, jalias, 0);
575
576   rv = MSG_task_listen_from_host(alias, host);
577
578   (*env)->ReleaseStringUTFChars(env, jalias, alias);
579
580   return (jint) rv;
581 }
582
583
584 JNIEXPORT jint JNICALL
585 Java_org_simgrid_msg_Task_listenFrom(JNIEnv * env, jclass cls,
586                                                         jstring jalias) {
587
588   int rv;
589   const char *alias = (*env)->GetStringUTFChars(env, jalias, 0);
590
591   rv = MSG_task_listen_from(alias);
592
593   (*env)->ReleaseStringUTFChars(env, jalias, alias);
594
595   return (jint) rv;
596 }