Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
e74aec4f8dcc4b5450a4b11a3357656a995c5b93
[simgrid.git] / src / java / jmsg.c
1 /*
2  * $Id$
3  *
4  * Copyright 2006,2007 Martin Quinson, Malek Cherier All right 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  * This contains the implementation of the wrapper functions used to interface
10  * the java object with the native functions of the MSG API.
11  */
12 #include "msg/msg.h"
13 #include "msg/private.h"
14 #include "simix/private.h"
15 #include "xbt/xbt_context_java.h"
16
17 #include "jmsg_process.h"
18 #include "jmsg_host.h"
19 #include "jmsg_task.h"
20 #include "jmsg_channel.h"
21 #include "jxbt_utilities.h"
22
23 #include "jmsg.h"
24
25 #include "msg/mailbox.h"
26
27 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
28
29 static JavaVM * __java_vm = NULL;
30
31 static jobject
32 native_to_java_process(m_process_t process);
33
34 JavaVM *
35 get_java_VM(void) {
36         return __java_vm;
37 }
38
39 JNIEnv *
40 get_current_thread_env(void) {
41         JNIEnv *env;
42
43     (*__java_vm)->AttachCurrentThread(__java_vm, (void **)&env, NULL);
44
45          return env;
46 }
47
48 static jobject
49 native_to_java_process(m_process_t process)
50 {
51         return ((xbt_ctx_java_t)(process->simdata->s_process->simdata->context))->jprocess;     
52 }
53
54
55 /*
56  * The MSG process connected functions implementation.                                 
57  */
58
59 JNIEXPORT void JNICALL 
60 Java_simgrid_msg_MsgNative_processCreate(JNIEnv* env, jclass cls, jobject jprocess_arg, jobject jhost) {
61   jobject jprocess;             /* the global reference to the java process instance    */
62   jstring jname;                /* the name of the java process instance                */
63   const char* name;             /* the C name of the process                            */
64   m_process_t process;          /* the native process to create                         */
65   char alias[MAX_ALIAS_NAME + 1] = {0};
66   msg_mailbox_t mailbox;
67
68   DEBUG4("Java_simgrid_msg_MsgNative_processCreate(env=%p,cls=%p,jproc=%p,jhost=%p)",
69          env,cls,jprocess_arg,jhost);
70   /* get the name of the java process */
71   jname = jprocess_get_name(jprocess_arg,env);
72
73   if (!jname) {
74     jxbt_throw_null(env,xbt_strdup("Internal error: Process name cannot be NULL"));
75     return;
76   }
77         
78   /* allocate the data of the simulation */
79   process = xbt_new0(s_m_process_t,1);
80   process->simdata = xbt_new0(s_simdata_process_t,1);
81     
82   /* create a global java process instance */
83   jprocess = jprocess_new_global_ref(jprocess_arg,env);
84
85   if(!jprocess) {
86     free(process->simdata);
87     free(process);
88     jxbt_throw_jni(env, "Can't get a global ref to the java process");
89     return;
90   }
91         
92   /* bind the java process instance to the native process */
93   jprocess_bind(jprocess,process,env);
94         
95   /* build the C name of the process */
96   name = (*env)->GetStringUTFChars(env, jname, 0);
97   process->name = xbt_strdup(name);
98   (*env)->ReleaseStringUTFChars(env, jname, name);
99         
100   process->simdata->m_host = jhost_get_native(env,jhost);
101
102
103   if( ! (process->simdata->m_host) ) { /* not binded */
104     free(process->simdata);
105     free(process->data);
106     free(process);
107     jxbt_throw_notbound(env,"host",jhost);
108     return;
109   }
110   process->simdata->PID = msg_global->PID++;
111     
112   /* create a new context */
113   DEBUG8("fill in process %s/%s (pid=%d) %p (sd=%p, host=%p, host->sd=%p); env=%p",
114          process->name,process->simdata->m_host->name,
115          process->simdata->PID,process,
116          process->simdata, process->simdata->m_host, process->simdata->m_host->simdata,
117          env);
118   
119   SIMIX_jprocess_create(process->name,
120                         process->simdata->m_host->simdata->smx_host, 
121                         /*data*/ (void*)process,
122                         jprocess,env,
123                         &process->simdata->s_process);
124
125   
126   DEBUG1("context created (s_process=%p)",process->simdata->s_process);
127
128
129   if (SIMIX_process_self()) { /* someone created me */
130     process->simdata->PPID = MSG_process_get_PID(SIMIX_process_self()->data);
131   } else {
132     process->simdata->PPID = -1;
133   }
134     
135   process->simdata->last_errno = MSG_OK;
136     
137   /* add the process to the list of the processes of the simulation */
138   xbt_fifo_unshift(msg_global->process_list, process);
139
140   sprintf(alias,"%s:%s",(process->simdata->m_host->simdata->smx_host)->name,process->name);
141   
142   mailbox = MSG_mailbox_new(alias);
143   MSG_mailbox_set_hostname(mailbox, process->simdata->m_host->simdata->smx_host->name);
144
145         
146 }
147
148 JNIEXPORT void JNICALL 
149 Java_simgrid_msg_MsgNative_processSuspend(JNIEnv* env, jclass cls, jobject jprocess) {
150   m_process_t process = jprocess_to_native_process(jprocess,env);
151
152   if(!process) { 
153     jxbt_throw_notbound(env,"process",jprocess);
154     return;
155   }
156         
157   /* try to suspend the process */
158   if(MSG_OK != MSG_process_suspend(process)) 
159     jxbt_throw_native(env, xbt_strdup("MSG_process_suspend() failed"));
160 }
161
162 JNIEXPORT void JNICALL 
163 Java_simgrid_msg_MsgNative_processResume(JNIEnv* env, jclass cls, jobject jprocess) {
164   m_process_t process = jprocess_to_native_process(jprocess,env);
165
166   if(!process) { 
167     jxbt_throw_notbound(env,"process",jprocess);
168     return;
169   }
170         
171   /* try to resume the process */
172   if(MSG_OK != MSG_process_resume(process))
173     jxbt_throw_native(env, xbt_strdup("MSG_process_resume() failed"));
174 }
175
176 JNIEXPORT jboolean JNICALL 
177 Java_simgrid_msg_MsgNative_processIsSuspended(JNIEnv* env, jclass cls, jobject jprocess) {
178   m_process_t process = jprocess_to_native_process(jprocess,env);
179
180   if(!process) { 
181     jxbt_throw_notbound(env,"process",jprocess);
182     return 0;
183   }
184
185   /* true is the process is suspended, false otherwise */
186   return (jboolean)MSG_process_is_suspended(process);
187 }
188
189 JNIEXPORT void JNICALL 
190 Java_simgrid_msg_MsgNative_processKill(JNIEnv* env, jclass cls, jobject jprocess) {
191   /* get the native instances from the java ones */
192   m_process_t process = jprocess_to_native_process(jprocess,env);
193
194   if(!process) { 
195     jxbt_throw_notbound(env,"process",jprocess);
196     return;
197   }
198
199   /* delete the global reference */
200   jprocess_delete_global_ref(native_to_java_process(process),env);
201         
202   /* kill the native process (this wrapper is call by the destructor of the java 
203    * process instance)
204    */
205   MSG_process_kill(process);
206 }
207
208 JNIEXPORT jobject JNICALL 
209 Java_simgrid_msg_MsgNative_processGetHost(JNIEnv* env, jclass cls, jobject jprocess) {
210   /* get the native instances from the java ones */
211   m_process_t process = jprocess_to_native_process(jprocess,env);
212   m_host_t host;
213         
214   if(!process) { 
215     jxbt_throw_notbound(env,"process",jprocess);
216     return NULL;
217   }
218
219   host = MSG_process_get_host(process);
220         
221   if(!host->data) {
222     jxbt_throw_native(env, xbt_strdup("MSG_process_get_host() failed"));
223     return NULL;
224   }
225
226   /* return the global reference to the java host instance */
227   return (jobject)host->data;
228         
229 }
230
231 JNIEXPORT jobject JNICALL 
232 Java_simgrid_msg_MsgNative_processFromPID(JNIEnv* env, jclass cls, jint PID) {
233   m_process_t process = MSG_process_from_PID(PID);
234
235   if(!process) {
236     jxbt_throw_process_not_found(env, bprintf("PID = %d",PID));
237     return NULL;
238   }
239
240   if(!native_to_java_process(process)) {
241     jxbt_throw_native(env, xbt_strdup("SIMIX_process_get_jprocess() failed"));
242     return NULL;
243   }
244
245   return (jobject)(native_to_java_process(process));
246 }
247
248
249 JNIEXPORT jint JNICALL 
250 Java_simgrid_msg_MsgNative_processGetPID(JNIEnv* env, jclass cls, jobject jprocess) {
251   m_process_t process = jprocess_to_native_process(jprocess,env);
252
253   if(!process) { 
254     jxbt_throw_notbound(env,"process",jprocess);
255     return 0;
256   }
257
258   return (jint)MSG_process_get_PID(process);    
259 }
260
261
262 JNIEXPORT jint JNICALL 
263 Java_simgrid_msg_MsgNative_processGetPPID(JNIEnv* env, jclass cls, jobject jprocess) {
264   m_process_t process = jprocess_to_native_process(jprocess,env);
265
266   if(!process) {
267     jxbt_throw_notbound(env,"process",jprocess);
268     return 0;
269   }
270
271   return (jint)MSG_process_get_PPID(process);
272 }
273
274 JNIEXPORT jobject JNICALL 
275 Java_simgrid_msg_MsgNative_processSelf(JNIEnv* env, jclass cls) {
276   m_process_t process = MSG_process_self();
277   jobject jprocess;
278
279   if(!process) {
280     jxbt_throw_native(env, xbt_strdup("MSG_process_self() failed"));
281     return NULL;
282   }
283
284   jprocess = native_to_java_process(process);
285
286   if(!jprocess)
287     jxbt_throw_native(env, xbt_strdup("SIMIX_process_get_jprocess() failed"));
288   
289   return jprocess;
290 }
291
292
293 JNIEXPORT jint JNICALL
294 Java_simgrid_msg_MsgNative_processSelfPID(JNIEnv* env, jclass cls) {
295   return (jint)MSG_process_self_PID();
296 }
297
298
299 JNIEXPORT jint JNICALL
300 Java_simgrid_msg_MsgNative_processSelfPPID(JNIEnv* env, jclass cls) {
301   return (jint)MSG_process_self_PPID();
302 }
303
304 JNIEXPORT void JNICALL 
305 Java_simgrid_msg_MsgNative_processChangeHost(JNIEnv* env, jclass cls, jobject jprocess, jobject jhost){
306   m_host_t host = jhost_get_native(env,jhost);
307   m_process_t process = jprocess_to_native_process(jprocess,env);
308         
309   if(!process) {
310     jxbt_throw_notbound(env,"process",jprocess);
311     return;
312   }
313         
314   if(!host) {
315     jxbt_throw_notbound(env,"host",jhost);
316     return;
317   }
318
319   /* try to change the host of the process */
320   if(MSG_OK != MSG_process_change_host(process,host))
321     jxbt_throw_native(env, xbt_strdup("MSG_process_change_host() failed"));
322 }
323
324 JNIEXPORT void JNICALL 
325 Java_simgrid_msg_MsgNative_processWaitFor(JNIEnv* env, jclass cls,jdouble seconds) {
326   if(MSG_OK != MSG_process_sleep((double)seconds))
327     jxbt_throw_native(env, 
328                        bprintf("MSG_process_change_host(%f) failed", (double)seconds));
329 }
330
331
332 /***************************************************************************************
333  * The MSG host connected functions implementation.                                    *
334  ***************************************************************************************/
335
336 JNIEXPORT jobject JNICALL 
337 Java_simgrid_msg_MsgNative_hostGetByName(JNIEnv* env, jclass cls, jstring jname) {
338   m_host_t host;                /* native host                                          */
339   jobject jhost;                /* global reference to the java host instance returned  */
340         
341   /* get the C string from the java string*/
342   const char* name = (*env)->GetStringUTFChars(env, jname, 0);
343         
344   /* get the host by name       (the hosts are created during the grid resolution) */
345   host = MSG_get_host_by_name(name);
346   DEBUG2("MSG gave %p as native host (simdata=%p)",host,host->simdata);
347         
348   (*env)->ReleaseStringUTFChars(env, jname, name); 
349
350   if(!host) {/* invalid name */
351     jxbt_throw_host_not_found(env,name);
352     return NULL;
353   }
354
355   if(!host->data) { /* native host not associated yet with java host */
356                 
357     /* instanciate a new java host */
358     jhost = jhost_new_instance(env);
359
360     if(!jhost) {
361       jxbt_throw_jni(env,"java host instantiation failed");
362       return NULL;
363     }
364                 
365     /* get a global reference to the newly created host */
366     jhost = jhost_ref(env,jhost);
367
368     if(!jhost) {
369       jxbt_throw_jni(env,"new global ref allocation failed");
370       return NULL;
371     }
372                 
373     /* bind the java host and the native host */
374     jhost_bind(jhost,host,env);
375                 
376     /* the native host data field is set with the global reference to the 
377      * java host returned by this function 
378      */
379     host->data = (void*)jhost;
380   }
381
382   /* return the global reference to the java host instance */
383   return (jobject)host->data;                   
384 }
385
386 JNIEXPORT jstring JNICALL 
387 Java_simgrid_msg_MsgNative_hostGetName(JNIEnv* env, jclass cls, jobject jhost) {
388   m_host_t host = jhost_get_native(env,jhost);
389
390   if(!host) {
391     jxbt_throw_notbound(env,"host",jhost);
392     return NULL;
393   }
394
395   return (*env)->NewStringUTF(env,host->name);
396 }
397
398 JNIEXPORT jint JNICALL 
399 Java_simgrid_msg_MsgNative_hostGetNumber(JNIEnv* env, jclass cls) {
400   return (jint)MSG_get_host_number();
401 }
402
403 JNIEXPORT jobject JNICALL
404 Java_simgrid_msg_MsgNative_hostSelf(JNIEnv* env, jclass cls) {
405   jobject jhost;
406         
407   m_host_t host = MSG_host_self();
408         
409   if(!host->data) {
410     /* the native host not yet associated with the java host instance */
411     
412     /* instanciate a new java host instance */
413     jhost = jhost_new_instance(env);
414     
415     if(!jhost) {
416       jxbt_throw_jni(env,"java host instantiation failed");
417       return NULL;
418     }
419     
420     /* get a global reference to the newly created host */
421     jhost = jhost_ref(env,jhost);
422     
423     if(!jhost) {
424       jxbt_throw_jni(env,"global ref allocation failed");
425       return NULL;
426     }
427
428     /* Bind & store it */
429     jhost_bind(jhost,host,env);
430     host->data = (void*)jhost;
431   } else {
432     jhost = (jobject)host->data;
433   }
434         
435   return jhost;
436 }
437
438 JNIEXPORT jdouble JNICALL 
439 Java_simgrid_msg_MsgNative_hostGetSpeed(JNIEnv* env, jclass cls, jobject jhost) {
440   m_host_t host = jhost_get_native(env,jhost);
441
442   if(!host) {
443     jxbt_throw_notbound(env,"host",jhost);
444     return -1;
445   }
446   
447   return (jdouble)MSG_get_host_speed(host);     
448 }
449
450 JNIEXPORT jint JNICALL 
451 Java_simgrid_msg_MsgNative_hostGetLoad(JNIEnv* env, jclass cls, jobject jhost) {
452   m_host_t host = jhost_get_native(env,jhost);
453
454   if(!host) {
455     jxbt_throw_notbound(env,"host",jhost);
456     return -1;
457   }
458
459   return (jint)MSG_get_host_msgload(host);      
460 }
461
462
463 JNIEXPORT jboolean JNICALL 
464 Java_simgrid_msg_MsgNative_hostIsAvail(JNIEnv* env, jclass cls, jobject jhost) {
465   m_host_t host = jhost_get_native(env,jhost);
466   
467   if(!host) {
468     jxbt_throw_notbound(env,"host",jhost);
469     return 0;
470   }
471
472   return (jboolean)MSG_host_is_avail(host);
473 }
474
475
476 /***************************************************************************************
477  * The MSG task connected functions implementation.                                    *
478  ***************************************************************************************/
479
480 JNIEXPORT void JNICALL 
481 Java_simgrid_msg_MsgNative_taskCreate(JNIEnv* env, jclass cls, jobject jtask, jstring jname, 
482                                 jdouble jcomputeDuration, jdouble jmessageSize) {
483   m_task_t task;        /* the native task to create                            */
484   const char* name;     /* the name of the task                                 */
485
486   if(jcomputeDuration < 0) {
487     jxbt_throw_illegal(env,bprintf("Task ComputeDuration (%f) cannot be negative",
488                                     (double)jcomputeDuration));
489     return;
490   }
491
492   if(jmessageSize < 0) {
493     jxbt_throw_illegal(env,bprintf("Task MessageSize (%f) cannot be negative",
494                                     (double)jmessageSize));
495     return;
496   }
497
498   if(!jname) {
499     jxbt_throw_null(env,xbt_strdup("Task name cannot be null"));
500     return;
501   }
502         
503   /* get the C string from the java string*/
504   name = (*env)->GetStringUTFChars(env, jname, 0);
505         
506   /* create the task */
507   task = MSG_task_create(name,(double)jcomputeDuration,(double)jmessageSize,NULL);
508         
509   (*env)->ReleaseStringUTFChars(env, jname, name); 
510         
511   /* bind & store the task */
512   jtask_bind(jtask,task,env);
513
514   /* allocate a new global reference to the java task instance */       
515   task->data = (void*)jtask_new_global_ref(jtask,env);
516
517   if ( ! task->data )
518     jxbt_throw_jni(env,"global ref allocation failed");
519
520 }
521
522 JNIEXPORT void JNICALL 
523 Java_simgrid_msg_MsgNative_parallel_taskCreate(JNIEnv* env, jclass cls, jobject jtask, jstring jname, 
524                                          jobjectArray jhosts,jdoubleArray jcomputeDurations_arg, jdoubleArray jmessageSizes_arg) {
525
526   m_task_t task;        /* the native parallel task to create           */
527   const char* name;     /* the name of the task                         */
528   int host_count;
529   m_host_t* hosts;
530   double* computeDurations;
531   double* messageSizes;
532   jdouble *jcomputeDurations;
533   jdouble *jmessageSizes;
534
535   jobject jhost;
536   int index;
537
538
539   if (!jcomputeDurations_arg) {
540     jxbt_throw_null(env,xbt_strdup("Parallel task compute durations cannot be null"));
541     return;
542   }
543
544   if(!jmessageSizes_arg){
545     jxbt_throw_null(env,xbt_strdup("Parallel task message sizes cannot be null"));
546     return;
547   }
548
549   if(!jname) {
550     jxbt_throw_null(env,xbt_strdup("Parallel task name cannot be null"));
551     return;
552   }
553
554   host_count = (int)(*env)->GetArrayLength(env,jhosts);
555         
556
557   hosts = xbt_new0(m_host_t,host_count);
558   computeDurations = xbt_new0(double,host_count);
559   messageSizes = xbt_new0(double,host_count*host_count);
560
561   jcomputeDurations = (*env)->GetDoubleArrayElements(env,jcomputeDurations_arg, 0);
562   jmessageSizes = (*env)->GetDoubleArrayElements(env,jmessageSizes_arg, 0);
563
564   for(index = 0; index < host_count; index++) {
565     jhost = (*env)->GetObjectArrayElement(env,jhosts,index);
566     hosts[index] = jhost_get_native(env,jhost);
567     computeDurations[index] = jcomputeDurations[index];
568   }
569   for(index = 0; index < host_count*host_count; index++) {
570     messageSizes[index] = jmessageSizes[index];
571   }   
572    
573   (*env)->ReleaseDoubleArrayElements(env,jcomputeDurations_arg,jcomputeDurations,0);
574   (*env)->ReleaseDoubleArrayElements(env,jmessageSizes_arg,jmessageSizes,0);
575
576         
577   /* get the C string from the java string*/
578   name = (*env)->GetStringUTFChars(env, jname, 0);
579         
580   task = MSG_parallel_task_create(name,host_count,hosts,computeDurations,messageSizes,NULL);
581
582   (*env)->ReleaseStringUTFChars(env, jname, name); 
583         
584   /* associate the java task object and the native task */
585   jtask_bind(jtask,task,env);
586
587   task->data = (void*)jtask;
588
589   if (! task->data )
590     jxbt_throw_jni(env,"global ref allocation failed");
591 }
592
593 JNIEXPORT jobject JNICALL 
594 Java_simgrid_msg_MsgNative_taskGetSender(JNIEnv* env , jclass cls , jobject jtask) {
595   m_process_t process;
596         
597   m_task_t task = jtask_to_native_task(jtask,env);
598         
599   if(!task){
600     jxbt_throw_notbound(env,"task",jtask);
601     return NULL;
602   }
603         
604   process = MSG_task_get_sender(task);
605   return (jobject)native_to_java_process(process);
606 }
607
608 JNIEXPORT jobject JNICALL 
609 Java_simgrid_msg_MsgNative_taskGetSource(JNIEnv* env , jclass cls, jobject jtask) {
610   m_host_t host;
611   m_task_t task = jtask_to_native_task(jtask,env);
612
613   if(!task){
614     jxbt_throw_notbound(env,"task",jtask);
615     return NULL;
616   }
617         
618   host = MSG_task_get_source(task);
619
620   if(! host->data) {
621     jxbt_throw_native(env, xbt_strdup("MSG_task_get_source() failed"));
622     return NULL;
623   }
624         
625   return (jobject)host->data;   
626 }
627
628
629 JNIEXPORT jstring JNICALL 
630 Java_simgrid_msg_MsgNative_taskGetName(JNIEnv* env, jclass cls, jobject jtask) {
631   m_task_t task = jtask_to_native_task(jtask,env);
632
633   if(!task){
634     jxbt_throw_notbound(env,"task",jtask);
635     return NULL;
636   }
637
638   return (*env)->NewStringUTF(env,task->name);          
639 }
640
641 JNIEXPORT void JNICALL 
642 Java_simgrid_msg_MsgNative_taskCancel(JNIEnv* env, jclass cls, jobject jtask) {
643   m_task_t ptask = jtask_to_native_task(jtask,env);
644  
645   if(!ptask){
646     jxbt_throw_notbound(env,"task",jtask);
647     return;
648   }
649         
650   if(MSG_OK != MSG_task_cancel(ptask))
651     jxbt_throw_native(env, xbt_strdup("MSG_task_cancel() failed"));
652 }
653
654 JNIEXPORT jdouble JNICALL 
655 Java_simgrid_msg_MsgNative_taskGetComputeDuration(JNIEnv* env, jclass cls, jobject jtask) {
656   m_task_t ptask = jtask_to_native_task(jtask,env);
657
658   if(!ptask){
659     jxbt_throw_notbound(env,"task",jtask);
660     return -1;
661   }
662   return (jdouble)MSG_task_get_compute_duration(ptask);
663 }
664
665 JNIEXPORT jdouble JNICALL 
666 Java_simgrid_msg_MsgNative_taskGetRemainingDuration(JNIEnv* env, jclass cls, jobject jtask) {
667   m_task_t ptask = jtask_to_native_task(jtask,env);
668
669   if(!ptask){
670     jxbt_throw_notbound(env,"task",jtask);
671     return -1;
672   }
673   return (jdouble)MSG_task_get_remaining_computation(ptask);
674 }
675
676 JNIEXPORT void JNICALL 
677 Java_simgrid_msg_MsgNative_taskSetPriority(JNIEnv* env, jclass cls, jobject jtask, jdouble priority) {
678   m_task_t task = jtask_to_native_task(jtask,env);
679
680   if(!task){
681     jxbt_throw_notbound(env,"task",jtask);
682     return;
683   }
684   MSG_task_set_priority(task,(double)priority);
685 }
686
687 JNIEXPORT void JNICALL 
688 Java_simgrid_msg_MsgNative_taskDestroy(JNIEnv* env, jclass cls, jobject jtask_arg) {
689
690   /* get the native task */
691   m_task_t task = jtask_to_native_task(jtask_arg,env);
692   jobject jtask;
693
694   if(!task){
695     jxbt_throw_notbound(env,"task",task);
696     return;
697   }
698   jtask = (jobject)task->data;
699
700   if(MSG_OK != MSG_task_destroy(task))
701     jxbt_throw_native(env, xbt_strdup("MSG_task_destroy() failed"));
702
703   /* delete the global reference to the java task object */
704   jtask_delete_global_ref(jtask,env);
705 }
706
707 JNIEXPORT void JNICALL 
708 Java_simgrid_msg_MsgNative_taskExecute(JNIEnv* env, jclass cls, jobject jtask) {
709   m_task_t task = jtask_to_native_task(jtask,env);
710
711   if(!task){
712     jxbt_throw_notbound(env,"task",jtask);
713     return;
714   }
715
716   if(MSG_OK != MSG_task_execute(task))
717     jxbt_throw_native(env, xbt_strdup("MSG_task_execute() failed"));
718 }
719
720 /***************************************************************************************
721  * The Task reception functions                                                        *
722  ***************************************************************************************/
723
724 JNIEXPORT jobject JNICALL 
725 Java_simgrid_msg_MsgNative_taskGet(JNIEnv* env, jclass cls, 
726                              jint chan_id, jdouble jtimeout, jobject jhost) {
727   m_task_t task = NULL;
728   m_host_t host = NULL;
729         
730   if (jhost) {
731      host = jhost_get_native(env,jhost);
732      if(!host){
733         jxbt_throw_notbound(env,"host",jhost);
734         return NULL;
735      }  
736   }   
737    
738   if (MSG_OK != MSG_task_get_ext(&task,(int)chan_id,(double)jtimeout,host)) {
739     jxbt_throw_native(env, xbt_strdup("MSG_task_get_ext() failed"));
740     return NULL;
741   }
742         
743   return (jobject)task->data;
744 }
745
746
747 JNIEXPORT jboolean JNICALL 
748 Java_simgrid_msg_MsgNative_taskProbe(JNIEnv* env, jclass cls, jint chan_id) {
749   return (jboolean)MSG_task_Iprobe(chan_id);
750 }
751
752 JNIEXPORT jobject JNICALL 
753 Java_simgrid_msg_MsgNative_taskGetCommunicatingProcess(JNIEnv* env, jclass cls, jint chan_id) {
754   int pid = MSG_task_probe_from(chan_id);
755   if (pid>=0) 
756      return Java_simgrid_msg_MsgNative_processFromPID(env,cls,(jint)pid);
757   
758   return NULL;
759 }
760
761 JNIEXPORT jint JNICALL 
762 Java_simgrid_msg_MsgNative_taskProbeHost(JNIEnv* env, jclass cls, 
763                                    jobject jhost, jint chan_id) {
764   m_host_t host = jhost_get_native(env,jhost);
765
766   if(!host){
767     jxbt_throw_notbound(env,"host",jhost);
768     return -1;
769   }
770
771   return (jint)MSG_task_probe_from_host(chan_id,host);
772 }
773
774
775 /***************************************************************************************
776  * The Task reception functions                                                        *
777  ***************************************************************************************/
778
779
780 JNIEXPORT void JNICALL 
781 Java_simgrid_msg_MsgNative_hostPut(JNIEnv* env, jclass cls, 
782                              jobject jhost, jint chan_id, jobject jtask, 
783                              jdouble jtimeout) {
784   m_task_t task = jtask_to_native_task(jtask,env);
785   m_host_t host = jhost_get_native(env,jhost);
786
787   if(!host){
788     jxbt_throw_notbound(env,"host",jhost);
789     return;
790   }
791   if(!task){
792     jxbt_throw_notbound(env,"task",jtask);
793     return;
794   }
795    
796   if(MSG_OK != MSG_task_put_with_timeout(task,host,(int)chan_id,(double)jtimeout))
797     jxbt_throw_native(env, xbt_strdup("MSG_task_put_with_timeout() failed"));
798 }
799
800
801
802 JNIEXPORT void JNICALL 
803 Java_simgrid_msg_MsgNative_hostPutBounded(JNIEnv* env, jclass cls, 
804                                     jobject jhost, jint chan_id, jobject jtask, 
805                                     jdouble jmaxRate) {
806   m_task_t task = jtask_to_native_task(jtask,env);
807   m_host_t host = jhost_get_native(env,jhost);
808
809   if(!host){
810     jxbt_throw_notbound(env,"host",jhost);
811     return;
812   }
813   if(!task){
814     jxbt_throw_notbound(env,"task",jtask);
815     return;
816   }
817          
818   if(MSG_OK != MSG_task_put_bounded(task,host,(int)chan_id,(double)jmaxRate))
819     jxbt_throw_native(env, xbt_strdup("MSG_task_put_bounded() failed"));
820 }
821
822 JNIEXPORT jint JNICALL 
823 Java_simgrid_msg_Msg_getErrCode(JNIEnv* env, jclass cls) {
824   return (jint)MSG_get_errno();
825 }
826
827 JNIEXPORT jdouble JNICALL 
828 Java_simgrid_msg_Msg_getClock(JNIEnv* env, jclass cls) {
829   return (jdouble)MSG_get_clock();
830 }
831
832
833 JNIEXPORT void JNICALL 
834 Java_simgrid_msg_Msg_init(JNIEnv* env, jclass cls, jobjectArray jargs) {
835         
836   char** argv = NULL;
837   int index;
838   int argc = 0;
839   jstring jval;
840   const char* tmp;
841         
842   if(jargs)
843     argc = (int)(*env)->GetArrayLength(env,jargs);
844
845   argc++;
846         
847   argv = xbt_new0(char*,1);
848          
849   argv[0] = strdup("java");
850         
851   for(index = 0; index < argc -1; index++) {
852     jval = (jstring)(*env)->GetObjectArrayElement(env,jargs,index);
853     
854     tmp = (*env)->GetStringUTFChars(env, jval, 0);
855     
856     argv[index +1] = strdup(tmp);
857
858     (*env)->ReleaseStringUTFChars(env, jval, tmp); 
859   }
860         
861   MSG_global_init(&argc,argv);
862   MSG_set_channel_number(10); /* FIXME: this should not be fixed statically */
863
864   for(index = 0; index < argc; index++)
865     free(argv[index]);
866         
867   free(argv);
868
869  (*env)->GetJavaVM(env,&__java_vm);
870         
871 }
872
873 JNIEXPORT void JNICALL
874 JNICALL Java_simgrid_msg_Msg_run(JNIEnv* env, jclass cls) {
875   xbt_fifo_item_t item = NULL;
876   m_host_t host = NULL;
877   jobject jhost;
878
879   /* Run everything */
880   if(MSG_OK != MSG_main())
881           jxbt_throw_native(env, xbt_strdup("MSG_main() failed"));
882         
883   DEBUG0("MSG_main finished. Bail out before cleanup since there is a bug in this part.");
884   
885   DEBUG0("Clean java world");
886   /* Cleanup java hosts */
887   xbt_fifo_foreach(msg_global->host,item,host,m_host_t) {
888     jhost = (jobject)host->data;
889         
890     if(jhost)
891       jhost_unref(env,jhost);
892   }
893         
894   DEBUG0("Clean native world");
895   /* cleanup native stuff */
896   if(MSG_OK != MSG_clean())
897     jxbt_throw_native(env, xbt_strdup("MSG_main() failed"));
898
899 }
900
901 JNIEXPORT jint JNICALL 
902 Java_simgrid_msg_MsgNative_processKillAll(JNIEnv* env, jclass cls, jint jresetPID) {
903   return (jint)MSG_process_killall((int)jresetPID);
904 }
905
906 JNIEXPORT void JNICALL 
907 Java_simgrid_msg_Msg_createEnvironment(JNIEnv* env, jclass cls,jstring jplatformFile) {
908         
909   const char* platformFile = (*env)->GetStringUTFChars(env, jplatformFile, 0);
910         
911   MSG_create_environment(platformFile);
912         
913   (*env)->ReleaseStringUTFChars(env, jplatformFile, platformFile); 
914 }
915
916 JNIEXPORT void JNICALL 
917 Java_simgrid_msg_MsgNative_processExit(JNIEnv* env, jclass cls, jobject jprocess) {
918
919   m_process_t process = jprocess_to_native_process(jprocess,env);
920
921   if (!process){
922     jxbt_throw_notbound(env,"process",jprocess);
923     return;
924   }
925
926   xbt_context_stop(0);
927 }
928
929 JNIEXPORT void JNICALL 
930 Java_simgrid_msg_Msg_pajeOutput(JNIEnv* env, jclass cls, jstring jpajeFile) {
931   const char*pajeFile = (*env)->GetStringUTFChars(env, jpajeFile, 0);
932         
933   MSG_paje_output(pajeFile);
934         
935   (*env)->ReleaseStringUTFChars(env, jpajeFile, pajeFile); 
936 }
937
938
939 JNIEXPORT void JNICALL 
940 Java_simgrid_msg_Msg_info(JNIEnv * env, jclass cls, jstring js) {
941   const char* s = (*env)->GetStringUTFChars(env,js,0);
942   INFO1("%s",s);
943   (*env)->ReleaseStringUTFChars(env, js, s);
944 }
945
946 JNIEXPORT jobjectArray JNICALL
947 Java_simgrid_msg_MsgNative_allHosts(JNIEnv * env, jclass cls_arg) {
948   int index;
949   jobjectArray jtable;
950   jobject jhost;
951   jstring jname;
952   m_host_t host;
953
954   int count = xbt_fifo_size(msg_global->host);
955   m_host_t* table = (m_host_t *)xbt_fifo_to_array(msg_global->host);
956         
957   jclass cls = jxbt_get_class(env,"simgrid/msg/Host");
958         
959   if(!cls){
960     return NULL;
961   }
962
963   jtable = (*env)->NewObjectArray(env,(jsize)count,cls,NULL);
964         
965   if(!jtable) {
966     jxbt_throw_jni(env,"Hosts table allocation failed");
967     return NULL;
968   }
969         
970   for(index = 0; index < count; index++) {
971     host = table[index];
972     jhost = (jobject)(host->data);
973     
974     if(!jhost) {
975       jname = (*env)->NewStringUTF(env,host->name);
976       
977       jhost = Java_simgrid_msg_MsgNative_hostGetByName(env,cls_arg,jname);
978       /* FIXME: leak of jname ? */
979     }
980     
981     (*env)->SetObjectArrayElement(env, jtable, index, jhost);
982   }
983
984   return jtable;
985 }
986
987
988 JNIEXPORT void JNICALL 
989 Java_simgrid_msg_MsgNative_selectContextFactory(JNIEnv * env, jclass class,jstring jname)
990 {
991         int rv;
992         
993         /* get the C string from the java string*/
994         const char* name = (*env)->GetStringUTFChars(env, jname, 0);
995
996         rv = xbt_context_select_factory(name);
997                 
998         (*env)->ReleaseStringUTFChars(env, jname, name);
999         
1000         if(rv)
1001                 jxbt_throw_native(env, xbt_strdup("xbt_select_context_factory() failed"));       
1002 }
1003
1004 JNIEXPORT void JNICALL 
1005 Java_simgrid_msg_MsgNative_taskSend(JNIEnv* env, jclass cls, 
1006                              jstring jalias, jobject jtask, 
1007                              jdouble jtimeout) {
1008         
1009         MSG_error_t rv;
1010         const char* alias = (*env)->GetStringUTFChars(env, jalias, 0);
1011
1012         m_task_t task = jtask_to_native_task(jtask,env);
1013
1014         
1015         if(!task){
1016                 (*env)->ReleaseStringUTFChars(env, jalias, alias);
1017                 jxbt_throw_notbound(env,"task",jtask);
1018                 return;
1019         }
1020
1021         rv = MSG_task_send_with_timeout(task,alias,(double)jtimeout);
1022
1023         (*env)->ReleaseStringUTFChars(env, jalias, alias);
1024
1025         if(MSG_OK != rv)
1026                 jxbt_throw_native(env, xbt_strdup("MSG_task_send_with_timeout() failed"));
1027
1028 }
1029
1030 JNIEXPORT void JNICALL 
1031 Java_simgrid_msg_MsgNative_taskSendBounded(JNIEnv* env, jclass cls, 
1032                                     jstring jalias, jobject jtask, 
1033                                     jdouble jmaxRate) {
1034   m_task_t task = jtask_to_native_task(jtask,env);
1035   MSG_error_t rv;
1036   const char* alias;
1037
1038   if(!task){
1039     jxbt_throw_notbound(env,"task",jtask);
1040     return;
1041   }
1042   
1043   alias = (*env)->GetStringUTFChars(env, jalias, 0);
1044         
1045   rv = MSG_task_send_bounded(task,alias,(double)jmaxRate);
1046   
1047   (*env)->ReleaseStringUTFChars(env, jalias, alias);
1048    
1049   if(MSG_OK != rv)
1050     jxbt_throw_native(env, xbt_strdup("MSG_task_send_bounded() failed"));
1051 }
1052
1053 JNIEXPORT jobject JNICALL 
1054 Java_simgrid_msg_MsgNative_taskReceive(JNIEnv* env, jclass cls, 
1055                              jstring jalias, jdouble jtimeout, jobject jhost) {
1056         MSG_error_t rv;
1057         m_task_t task = NULL;
1058         m_host_t host = NULL;
1059         const char* alias;
1060
1061         if (jhost) {
1062                 host = jhost_get_native(env,jhost);
1063                 
1064                 if(!host){
1065                         jxbt_throw_notbound(env,"host",jhost);
1066                         return NULL;
1067                 }  
1068         } 
1069
1070         alias = (*env)->GetStringUTFChars(env, jalias, 0);
1071
1072         rv = MSG_task_receive_ext(&task,alias,(double)jtimeout,host);   
1073
1074         (*env)->ReleaseStringUTFChars(env, jalias, alias);
1075         
1076         if (MSG_OK != rv) 
1077         {
1078                 jxbt_throw_native(env, xbt_strdup("MSG_task_receive_ext() failed"));
1079                 return NULL;
1080         }
1081
1082         return (jobject)task->data;
1083 }
1084
1085 JNIEXPORT jboolean JNICALL 
1086 Java_simgrid_msg_MsgNative_taskListen(JNIEnv* env, jclass cls, jstring jalias) {
1087         
1088   const char* alias;
1089   int rv;
1090   
1091   alias = (*env)->GetStringUTFChars(env, jalias, 0);
1092   
1093   rv = MSG_task_listen(alias);
1094   
1095   (*env)->ReleaseStringUTFChars(env, jalias, alias);
1096   
1097   return (jboolean)rv;
1098 }
1099
1100 JNIEXPORT jint JNICALL 
1101 Java_simgrid_msg_MsgNative_taskListenFromHost(JNIEnv* env, jclass cls, jstring jalias, jobject jhost) {
1102   
1103   int rv;
1104   const char* alias;
1105   
1106   m_host_t host = jhost_get_native(env,jhost);
1107
1108   if(!host){
1109     jxbt_throw_notbound(env,"host",jhost);
1110     return -1;
1111   }
1112   
1113   alias = (*env)->GetStringUTFChars(env, jalias, 0);
1114
1115   rv = MSG_task_listen_from_host(alias,host);
1116   
1117   (*env)->ReleaseStringUTFChars(env, jalias, alias);
1118   
1119   return (jint)rv;
1120 }
1121
1122 JNIEXPORT jint JNICALL 
1123 Java_simgrid_msg_MsgNative_taskListenFrom(JNIEnv* env, jclass cls, jstring jalias) {
1124   
1125   int rv;
1126   const char* alias = (*env)->GetStringUTFChars(env, jalias, 0);
1127
1128   rv = MSG_task_listen_from(alias);
1129   
1130   (*env)->ReleaseStringUTFChars(env, jalias, alias);
1131   
1132   return (jint)rv;
1133 }
1134