X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/bc0c0b491241f28c083c4b6540944ed604242ba2..0c5058e854366019f429316340bff257dd01cbb4:/src/java/jmsg.c diff --git a/src/java/jmsg.c b/src/java/jmsg.c index ed3e9d9af1..0d9ea2375c 100644 --- a/src/java/jmsg.c +++ b/src/java/jmsg.c @@ -11,327 +11,331 @@ */ #include "msg/msg.h" #include "msg/private.h" -#include "java/jxbt_context.h" +#include "simix/private.h" +#include "simix/smx_context_java.h" #include "jmsg_process.h" #include "jmsg_host.h" #include "jmsg_task.h" -#include "jmsg_parallel_task.h" -#include "jmsg_channel.h" +#include "jmsg_application_handler.h" #include "jxbt_utilities.h" -XBT_LOG_NEW_DEFAULT_CATEGORY(jmsg,"MSG for Java(TM)"); - -/* header for windows */ -#ifdef WIN32 -#include -#else -#include -#endif - #include "jmsg.h" +#include "msg/mailbox.h" +#include "surf/surfxml_parse.h" +XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg); -#ifdef WIN32 - static DWORD __current_thread_id = 0; +static JavaVM *__java_vm = NULL; - int is_main_thread() { - return (GetCurrentThreadId() == __current_thread_id); - } +static jobject native_to_java_process(m_process_t process); -#else /* !WIN32 */ +JavaVM *get_java_VM(void) +{ + return __java_vm; +} - static pthread_t __current_thread_id = 0; +JNIEnv *get_current_thread_env(void) +{ + JNIEnv *env; - int is_main_thread() { - return (pthread_self() == __current_thread_id); - } -#endif + (*__java_vm)->AttachCurrentThread(__java_vm, (void **) &env, NULL); + return env; +} + +static jobject native_to_java_process(m_process_t process) +{ + return ((smx_ctx_java_t) + (process->simdata->s_process->context))->jprocess; +} /* * The MSG process connected functions implementation. */ -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_processCreate(JNIEnv* env, jclass cls, jobject jprocess_arg, jobject jhost) { - jobject jprocess; /* the global reference to the java process instance */ - jstring jname; /* the name of the java process instance */ - const char* name; /* the C name of the process */ - m_process_t process; /* the native process to create */ - - - DEBUG4("Java_simgrid_msg_Msg_processCreate(env=%p,cls=%p,jproc=%p,jhost=%p)", - env,cls,jprocess_arg,jhost); +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_processCreate(JNIEnv * env, jclass cls, + jobject jprocess_arg, jobject jhost) +{ + jobject jprocess; /* the global reference to the java process instance */ + jstring jname; /* the name of the java process instance */ + const char *name; /* the C name of the process */ + m_process_t process; /* the native process to create */ + char alias[MAX_ALIAS_NAME + 1] = { 0 }; + msg_mailbox_t mailbox; + + DEBUG4 + ("Java_simgrid_msg_MsgNative_processCreate(env=%p,cls=%p,jproc=%p,jhost=%p)", + env, cls, jprocess_arg, jhost); /* get the name of the java process */ - jname = jprocess_get_name(jprocess_arg,env); + jname = jprocess_get_name(jprocess_arg, env); if (!jname) { - jxbt_throw_null(env,xbt_strdup("Internal error: Process name cannot be NULL")); + jxbt_throw_null(env, + xbt_strdup + ("Internal error: Process name cannot be NULL")); return; } - + /* allocate the data of the simulation */ - process = xbt_new0(s_m_process_t,1); - process->simdata = xbt_new0(s_simdata_process_t,1); - + process = xbt_new0(s_m_process_t, 1); + process->simdata = xbt_new0(s_simdata_process_t, 1); + /* create a global java process instance */ - jprocess = jprocess_new_global_ref(jprocess_arg,env); + jprocess = jprocess_new_global_ref(jprocess_arg, env); - if(!jprocess) { + if (!jprocess) { free(process->simdata); free(process); jxbt_throw_jni(env, "Can't get a global ref to the java process"); return; } - - /* bind the java process instance to the native host */ - jprocess_bind(jprocess,process,env); - + + /* bind the java process instance to the native process */ + jprocess_bind(jprocess, process, env); + /* build the C name of the process */ name = (*env)->GetStringUTFChars(env, jname, 0); process->name = xbt_strdup(name); (*env)->ReleaseStringUTFChars(env, jname, name); - - process->simdata->m_host = jhost_get_native(env,jhost); - if( ! (process->simdata->m_host) ) { /* not binded */ + + process->simdata->m_host = jhost_get_native(env, jhost); + + + if (!(process->simdata->m_host)) { /* not binded */ free(process->simdata); free(process->data); free(process); - jxbt_throw_notbound(env,"host",jhost); + jxbt_throw_notbound(env, "host", jhost); return; } process->simdata->PID = msg_global->PID++; - + /* create a new context */ - DEBUG8("fill in process %s/%s (pid=%d) %p (sd=%p, host=%p, host->sd=%p); env=%p", - process->name,process->simdata->m_host->name, - process->simdata->PID,process, - process->simdata, process->simdata->m_host, process->simdata->m_host->simdata, - env); - - SIMIX_jprocess_create(process->name, - process->simdata->m_host->simdata->s_host, - /*data*/ (void*)process, - jprocess_arg,env, - &process->simdata->s_process); - DEBUG1("context created (s_process=%p)",process->simdata->s_process); + DEBUG8 + ("fill in process %s/%s (pid=%d) %p (sd=%p, host=%p, host->sd=%p); env=%p", + process->name, process->simdata->m_host->name, process->simdata->PID, + process, process->simdata, process->simdata->m_host, + process->simdata->m_host->simdata, env); + + process->simdata->s_process = + SIMIX_process_create(process->name, (xbt_main_func_t)jprocess, + /*data */ (void *) process, + process->simdata->m_host->simdata->smx_host->name, + 0, NULL, NULL); + + DEBUG1("context created (s_process=%p)", process->simdata->s_process); - if (SIMIX_process_self()) { /* someone created me */ + if (SIMIX_process_self()) { /* someone created me */ process->simdata->PPID = MSG_process_get_PID(SIMIX_process_self()->data); } else { process->simdata->PPID = -1; } - + process->simdata->last_errno = MSG_OK; - -#ifdef KILLME - /* add the process in the list of the process of the host */ - xbt_fifo_unshift(host->simdata->process_list, process); - - self = msg_global->current_process; - - process->simdata->context->env = env; - - /* start the java process */ - xbt_context_start(process->simdata->context); - - msg_global->current_process = self; -#endif - /* add the process to the list of the processes of the simulation */ xbt_fifo_unshift(msg_global->process_list, process); - - /* add the process to the list of the processes to run in the simulation */ - // xbt_fifo_unshift(msg_global->process_to_run, process); - - // PAJE_PROCESS_NEW(process); - //#endif + + sprintf(alias, "%s:%s", (process->simdata->m_host->simdata->smx_host)->name, + process->name); + + mailbox = MSG_mailbox_new(alias); + } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_processSuspend(JNIEnv* env, jclass cls, jobject jprocess) { - m_process_t process = jprocess_to_native_process(jprocess,env); +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_processSuspend(JNIEnv * env, jclass cls, + jobject jprocess) +{ + m_process_t process = jprocess_to_native_process(jprocess, env); - if(!process) { - jxbt_throw_notbound(env,"process",jprocess); + if (!process) { + jxbt_throw_notbound(env, "process", jprocess); return; } - + /* try to suspend the process */ - if(MSG_OK != MSG_process_suspend(process)) - jxbt_throw_native(env, xbt_strdup("MSG_process_suspend() failed")); + MSG_error_t rv = MSG_process_suspend(process); + + jxbt_check_res("MSG_process_suspend()",rv,MSG_OK, + bprintf("unexpected error , please report this bug")); + } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_processResume(JNIEnv* env, jclass cls, jobject jprocess) { - m_process_t process = jprocess_to_native_process(jprocess,env); +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_processResume(JNIEnv * env, jclass cls, + jobject jprocess) +{ + m_process_t process = jprocess_to_native_process(jprocess, env); - if(!process) { - jxbt_throw_notbound(env,"process",jprocess); + if (!process) { + jxbt_throw_notbound(env,"process", jprocess); return; } - + /* try to resume the process */ - if(MSG_OK != MSG_process_resume(process)) - jxbt_throw_native(env, xbt_strdup("MSG_process_resume() failed")); + MSG_error_t rv = MSG_process_resume(process); + + jxbt_check_res("MSG_process_resume()",rv,MSG_OK, + bprintf("unexpected error , please report this bug")); } -JNIEXPORT jboolean JNICALL -Java_simgrid_msg_Msg_processIsSuspended(JNIEnv* env, jclass cls, jobject jprocess) { - m_process_t process = jprocess_to_native_process(jprocess,env); +JNIEXPORT jboolean JNICALL +Java_simgrid_msg_MsgNative_processIsSuspended(JNIEnv * env, jclass cls, + jobject jprocess) +{ + m_process_t process = jprocess_to_native_process(jprocess, env); - if(!process) { - jxbt_throw_notbound(env,"process",jprocess); + if (!process) { + jxbt_throw_notbound(env, "process", jprocess); return 0; } /* true is the process is suspended, false otherwise */ - return (jboolean)MSG_process_is_suspended(process); + return (jboolean) MSG_process_is_suspended(process); } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_processKill(JNIEnv* env, jclass cls, jobject jprocess) { +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_processKill(JNIEnv * env, jclass cls, + jobject jprocess) +{ /* get the native instances from the java ones */ - m_process_t process = jprocess_to_native_process(jprocess,env); + m_process_t process = jprocess_to_native_process(jprocess, env); - if(!process) { - jxbt_throw_notbound(env,"process",jprocess); + if (!process) { + jxbt_throw_notbound(env, "process", jprocess); return; } /* delete the global reference */ - jprocess_delete_global_ref(SIMIX_process_get_jprocess(process->simdata->s_process),env); - + jprocess_delete_global_ref(native_to_java_process(process), env); + /* kill the native process (this wrapper is call by the destructor of the java * process instance) */ MSG_process_kill(process); } -JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_processGetHost(JNIEnv* env, jclass cls, jobject jprocess) { +JNIEXPORT jobject JNICALL +Java_simgrid_msg_MsgNative_processGetHost(JNIEnv * env, jclass cls, + jobject jprocess) +{ /* get the native instances from the java ones */ - m_process_t process = jprocess_to_native_process(jprocess,env); + m_process_t process = jprocess_to_native_process(jprocess, env); m_host_t host; - - if(!process) { - jxbt_throw_notbound(env,"process",jprocess); + + if (!process) { + jxbt_throw_notbound(env, "process", jprocess); return NULL; } host = MSG_process_get_host(process); - - if(!host->data) { - jxbt_throw_native(env, xbt_strdup("MSG_process_get_host() failed")); + + if (!host->data) { + jxbt_throw_jni(env, "MSG_process_get_host() failed"); return NULL; } /* return the global reference to the java host instance */ - return (jobject)host->data; - + return (jobject) host->data; + } -JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_processFromPID(JNIEnv* env, jclass cls, jint PID) { +JNIEXPORT jobject JNICALL +Java_simgrid_msg_MsgNative_processFromPID(JNIEnv * env, jclass cls, jint PID) +{ m_process_t process = MSG_process_from_PID(PID); - if(!process) { - jxbt_throw_native(env, bprintf("MSG_process_from_PID(%d) failed",PID)); + if (!process) { + jxbt_throw_process_not_found(env, bprintf("PID = %d", PID)); return NULL; } - if(!SIMIX_process_get_jprocess(process->simdata->s_process)) { + if (!native_to_java_process(process)) { jxbt_throw_native(env, xbt_strdup("SIMIX_process_get_jprocess() failed")); return NULL; } - return (jobject)SIMIX_process_get_jprocess(process->simdata->s_process); + return (jobject) (native_to_java_process(process)); } -JNIEXPORT jint JNICALL -Java_simgrid_msg_Msg_processGetPID(JNIEnv* env, jclass cls, jobject jprocess) { - m_process_t process = jprocess_to_native_process(jprocess,env); +JNIEXPORT jint JNICALL +Java_simgrid_msg_MsgNative_processGetPID(JNIEnv * env, jclass cls, + jobject jprocess) +{ + m_process_t process = jprocess_to_native_process(jprocess, env); - if(!process) { - jxbt_throw_notbound(env,"process",jprocess); + if (!process) { + jxbt_throw_notbound(env, "process", jprocess); return 0; } - return (jint)MSG_process_get_PID(process); + return (jint) MSG_process_get_PID(process); } -JNIEXPORT jint JNICALL -Java_simgrid_msg_Msg_processGetPPID(JNIEnv* env, jclass cls, jobject jprocess) { - m_process_t process = jprocess_to_native_process(jprocess,env); +JNIEXPORT jint JNICALL +Java_simgrid_msg_MsgNative_processGetPPID(JNIEnv * env, jclass cls, + jobject jprocess) +{ + m_process_t process = jprocess_to_native_process(jprocess, env); - if(!process) { - jxbt_throw_notbound(env,"process",jprocess); + if (!process) { + jxbt_throw_notbound(env, "process", jprocess); return 0; } - return (jint)MSG_process_get_PPID(process); + return (jint) MSG_process_get_PPID(process); } -JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_processSelf(JNIEnv* env, jclass cls) { +JNIEXPORT jobject JNICALL +Java_simgrid_msg_MsgNative_processSelf(JNIEnv * env, jclass cls) +{ m_process_t process = MSG_process_self(); jobject jprocess; - if(!process) { + if (!process) { jxbt_throw_native(env, xbt_strdup("MSG_process_self() failed")); return NULL; } - jprocess = SIMIX_process_get_jprocess(process->simdata->s_process); + jprocess = native_to_java_process(process); - if(!jprocess) + if (!jprocess) jxbt_throw_native(env, xbt_strdup("SIMIX_process_get_jprocess() failed")); - - return jprocess; -} - -JNIEXPORT jint JNICALL -Java_simgrid_msg_Msg_processSelfPID(JNIEnv* env, jclass cls) { - return (jint)MSG_process_self_PID(); + return jprocess; } +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_processChangeHost(JNIEnv * env, jclass cls, + jobject jhost) +{ + m_host_t host = jhost_get_native(env, jhost); -JNIEXPORT jint JNICALL -Java_simgrid_msg_Msg_processSelfPPID(JNIEnv* env, jclass cls) { - return (jint)MSG_process_self_PPID(); -} - -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_processChangeHost(JNIEnv* env, jclass cls, jobject jprocess, jobject jhost){ - m_host_t host = jhost_get_native(env,jhost); - m_process_t process = jprocess_to_native_process(jprocess,env); - - if(!process) { - jxbt_throw_notbound(env,"process",jprocess); - return; - } - - if(!host) { - jxbt_throw_notbound(env,"host",jhost); + if (!host) { + jxbt_throw_notbound(env, "host", jhost); return; } /* try to change the host of the process */ - if(MSG_OK != MSG_process_change_host(process,host)) + if (MSG_OK != MSG_process_change_host(host)) jxbt_throw_native(env, xbt_strdup("MSG_process_change_host() failed")); } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_processWaitFor(JNIEnv* env, jclass cls,jdouble seconds) { - if(MSG_OK != MSG_process_sleep((double)seconds)) - jxbt_throw_native(env, - bprintf("MSG_process_change_host(%f) failed", (double)seconds)); +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_processWaitFor(JNIEnv * env, jclass cls, + jdouble seconds) +{ + MSG_error_t rv= MSG_process_sleep((double) seconds); + + jxbt_check_res("MSG_process_sleep()",rv, MSG_HOST_FAILURE, + bprintf("while process was waiting for %f seconds",(double)seconds)); + } @@ -339,143 +343,155 @@ Java_simgrid_msg_Msg_processWaitFor(JNIEnv* env, jclass cls,jdouble seconds) { * The MSG host connected functions implementation. * ***************************************************************************************/ -JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_hostGetByName(JNIEnv* env, jclass cls, jstring jname) { - m_host_t host; /* native host */ - jobject jhost; /* global reference to the java host instance returned */ - - /* get the C string from the java string*/ - const char* name = (*env)->GetStringUTFChars(env, jname, 0); - - /* get the host by name (the hosts are created during the grid resolution) */ +JNIEXPORT jobject JNICALL +Java_simgrid_msg_MsgNative_hostGetByName(JNIEnv * env, jclass cls, + jstring jname) +{ + m_host_t host; /* native host */ + jobject jhost; /* global reference to the java host instance returned */ + + /* get the C string from the java string */ + const char *name = (*env)->GetStringUTFChars(env, jname, 0); + + /* get the host by name (the hosts are created during the grid resolution) */ host = MSG_get_host_by_name(name); - DEBUG2("MSG gave %p as native host (simdata=%p)",host,host->simdata); - - (*env)->ReleaseStringUTFChars(env, jname, name); + DEBUG2("MSG gave %p as native host (simdata=%p)", host, host->simdata); - if(!host) {/* invalid name */ - jxbt_throw_host_not_found(env,name); + (*env)->ReleaseStringUTFChars(env, jname, name); + + if (!host) { /* invalid name */ + jxbt_throw_host_not_found(env, name); return NULL; } - if(!host->data) { /* native host not associated yet with java host */ - + if (!host->data) { /* native host not associated yet with java host */ + /* instanciate a new java host */ jhost = jhost_new_instance(env); - if(!jhost) { - jxbt_throw_jni(env,"java host instantiation failed"); + if (!jhost) { + jxbt_throw_jni(env, "java host instantiation failed"); return NULL; } - + /* get a global reference to the newly created host */ - jhost = jhost_ref(env,jhost); + jhost = jhost_ref(env, jhost); - if(!jhost) { - jxbt_throw_jni(env,"new global ref allocation failed"); + if (!jhost) { + jxbt_throw_jni(env, "new global ref allocation failed"); return NULL; } - + /* bind the java host and the native host */ - jhost_bind(jhost,host,env); - + jhost_bind(jhost, host, env); + /* the native host data field is set with the global reference to the * java host returned by this function */ - host->data = (void*)jhost; + host->data = (void *) jhost; } /* return the global reference to the java host instance */ - return (jobject)host->data; + return (jobject) host->data; } -JNIEXPORT jstring JNICALL -Java_simgrid_msg_Msg_hostGetName(JNIEnv* env, jclass cls, jobject jhost) { - m_host_t host = jhost_get_native(env,jhost); +JNIEXPORT jstring JNICALL +Java_simgrid_msg_MsgNative_hostGetName(JNIEnv * env, jclass cls, + jobject jhost) +{ + m_host_t host = jhost_get_native(env, jhost); - if(!host) { - jxbt_throw_notbound(env,"host",jhost); + if (!host) { + jxbt_throw_notbound(env, "host", jhost); return NULL; } - return (*env)->NewStringUTF(env,host->name); + return (*env)->NewStringUTF(env, host->name); } -JNIEXPORT jint JNICALL -Java_simgrid_msg_Msg_hostGetNumber(JNIEnv* env, jclass cls) { - return (jint)MSG_get_host_number(); +JNIEXPORT jint JNICALL +Java_simgrid_msg_MsgNative_hostGetNumber(JNIEnv * env, jclass cls) +{ + return (jint) MSG_get_host_number(); } JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_hostSelf(JNIEnv* env, jclass cls) { +Java_simgrid_msg_MsgNative_hostSelf(JNIEnv * env, jclass cls) +{ jobject jhost; - + m_host_t host = MSG_host_self(); - - if(!host->data) { + + if (!host->data) { /* the native host not yet associated with the java host instance */ - + /* instanciate a new java host instance */ jhost = jhost_new_instance(env); - - if(!jhost) { - jxbt_throw_jni(env,"java host instantiation failed"); + + if (!jhost) { + jxbt_throw_jni(env, "java host instantiation failed"); return NULL; } - + /* get a global reference to the newly created host */ - jhost = jhost_ref(env,jhost); - - if(!jhost) { - jxbt_throw_jni(env,"global ref allocation failed"); + jhost = jhost_ref(env, jhost); + + if (!jhost) { + jxbt_throw_jni(env, "global ref allocation failed"); return NULL; } /* Bind & store it */ - jhost_bind(jhost,host,env); - host->data = (void*)jhost; + jhost_bind(jhost, host, env); + host->data = (void *) jhost; } else { - jhost = (jobject)host->data; + jhost = (jobject) host->data; } - + return jhost; } -JNIEXPORT jdouble JNICALL -Java_simgrid_msg_Msg_hostGetSpeed(JNIEnv* env, jclass cls, jobject jhost) { - m_host_t host = jhost_get_native(env,jhost); +JNIEXPORT jdouble JNICALL +Java_simgrid_msg_MsgNative_hostGetSpeed(JNIEnv * env, jclass cls, + jobject jhost) +{ + m_host_t host = jhost_get_native(env, jhost); - if(!host) { - jxbt_throw_notbound(env,"host",jhost); + if (!host) { + jxbt_throw_notbound(env, "host", jhost); return -1; } - - return (jdouble)MSG_get_host_speed(host); + + return (jdouble) MSG_get_host_speed(host); } -JNIEXPORT jint JNICALL -Java_simgrid_msg_Msg_hostGetLoad(JNIEnv* env, jclass cls, jobject jhost) { - m_host_t host = jhost_get_native(env,jhost); +JNIEXPORT jint JNICALL +Java_simgrid_msg_MsgNative_hostGetLoad(JNIEnv * env, jclass cls, + jobject jhost) +{ + m_host_t host = jhost_get_native(env, jhost); - if(!host) { - jxbt_throw_notbound(env,"host",jhost); + if (!host) { + jxbt_throw_notbound(env, "host", jhost); return -1; } - return (jint)MSG_get_host_msgload(host); + return (jint) MSG_get_host_msgload(host); } -JNIEXPORT jboolean JNICALL -Java_simgrid_msg_Msg_hostIsAvail(JNIEnv* env, jclass cls, jobject jhost) { - m_host_t host = jhost_get_native(env,jhost); - - if(!host) { - jxbt_throw_notbound(env,"host",jhost); +JNIEXPORT jboolean JNICALL +Java_simgrid_msg_MsgNative_hostIsAvail(JNIEnv * env, jclass cls, + jobject jhost) +{ + m_host_t host = jhost_get_native(env, jhost); + + if (!host) { + jxbt_throw_notbound(env, "host", jhost); return 0; } - return (jboolean)MSG_host_is_avail(host); + return (jboolean) MSG_host_is_avail(host); } @@ -483,58 +499,68 @@ Java_simgrid_msg_Msg_hostIsAvail(JNIEnv* env, jclass cls, jobject jhost) { * The MSG task connected functions implementation. * ***************************************************************************************/ -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_taskCreate(JNIEnv* env, jclass cls, jobject jtask, jstring jname, - jdouble jcomputeDuration, jdouble jmessageSize) { - m_task_t task; /* the native task to create */ - const char* name; /* the name of the task */ - - if(jcomputeDuration < 0) { - jxbt_throw_illegal(env,bprintf("Task ComputeDuration (%f) cannot be negative", - (double)jcomputeDuration)); +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_taskCreate(JNIEnv * env, jclass cls, 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)); + if (jmessageSize < 0) { + jxbt_throw_illegal(env, + bprintf("Task MessageSize (%f) cannot be negative", + (double) jmessageSize)); return; } - if(!jname) { - jxbt_throw_null(env,xbt_strdup("Task name cannot be null")); - return; + if (jname) { + /* get the C string from the java string */ + name = (*env)->GetStringUTFChars(env, jname, 0); } - - /* 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); - - (*env)->ReleaseStringUTFChars(env, jname, name); - + task = + MSG_task_create(name, (double) jcomputeDuration, (double) jmessageSize, + NULL); + + if (jname) + (*env)->ReleaseStringUTFChars(env, jname, name); + /* bind & store the task */ - jtask_bind(jtask,task,env); + jtask_bind(jtask, task, env); - /* allocate a new global reference to the java task instance */ - task->data = (void*)jtask_new_global_ref(jtask,env); + /* allocate a new global reference to the java task instance */ + task->data = (void *) jtask_new_global_ref(jtask, env); - if ( ! task->data ) - jxbt_throw_jni(env,"global ref allocation failed"); -} + if (!task->data) + jxbt_throw_jni(env, "global ref allocation failed"); -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_parallel_taskCreate(JNIEnv* env, jclass cls, jobject jtask_arg, 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 */ - jobject jtask; /* the global reference to the java parallel task instance */ +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_parallel_taskCreate(JNIEnv * env, jclass cls, + 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; + m_host_t *hosts; + double *computeDurations; + double *messageSizes; jdouble *jcomputeDurations; jdouble *jmessageSizes; @@ -543,681 +569,577 @@ Java_simgrid_msg_Msg_parallel_taskCreate(JNIEnv* env, jclass cls, jobject jtask_ if (!jcomputeDurations_arg) { - jxbt_throw_null(env,xbt_strdup("Parallel task compute durations cannot be null")); + 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")); + 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")); + if (!jname) { + jxbt_throw_null(env, xbt_strdup("Parallel task name cannot be null")); return; } - host_count = (int)(*env)->GetArrayLength(env,jhosts); - + host_count = (int) (*env)->GetArrayLength(env, jhosts); - hosts = (m_host_t*)calloc(host_count,sizeof(m_host_t)); - computeDurations = (double*)calloc(host_count,sizeof(double)); - messageSizes = (double*)calloc(host_count,sizeof(double)); - jcomputeDurations = (*env)->GetDoubleArrayElements(env,jcomputeDurations_arg, 0); - jmessageSizes = (*env)->GetDoubleArrayElements(env,jmessageSizes_arg, 0); + hosts = xbt_new0(m_host_t, host_count); + computeDurations = xbt_new0(double, host_count); + messageSizes = xbt_new0(double, host_count * host_count); - for(index = 0; index < host_count; index++) { - jhost = (*env)->GetObjectArrayElement(env,jhosts,index); - hosts[index] = jhost_get_native(env,jhost); + 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); + (*env)->ReleaseDoubleArrayElements(env, jcomputeDurations_arg, + jcomputeDurations, 0); + (*env)->ReleaseDoubleArrayElements(env, jmessageSizes_arg, jmessageSizes, + 0); - - /* get the C string from the java string*/ + + /* 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); - - /* allocate a new global reference to the java task instance */ - jtask = jparallel_task_ref(env,jtask_arg); - + task = + MSG_parallel_task_create(name, host_count, hosts, computeDurations, + messageSizes, NULL); + + (*env)->ReleaseStringUTFChars(env, jname, name); + /* associate the java task object and the native task */ - jparallel_task_bind(jtask,task,env); + jtask_bind(jtask, task, env); - task->data = (void*)jtask; + task->data = (void *) jtask; - if(!(task->data)) - jxbt_throw_jni(env,"global ref allocation failed"); + if (!task->data) + jxbt_throw_jni(env, "global ref allocation failed"); } -JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_taskGetSender(JNIEnv* env , jclass cls , jobject jtask) { +JNIEXPORT jobject JNICALL +Java_simgrid_msg_MsgNative_taskGetSender(JNIEnv * env, jclass cls, + 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); - return SIMIX_process_get_jprocess(process->simdata->s_process); -} -JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_parallelTaskGetSender(JNIEnv* env , jclass cls , jobject jtask) { - m_task_t task; - m_process_t process; - - task = jparallel_task_to_native_parallel_task(jtask,env); + m_task_t task = jtask_to_native_task(jtask, env); - if(!task) { - jxbt_throw_notbound(env,"task",jtask); + if (!task) { + jxbt_throw_notbound(env, "task", jtask); return NULL; } - + process = MSG_task_get_sender(task); - - return SIMIX_process_get_jprocess(process->simdata->s_process); + return (jobject) native_to_java_process(process); } -JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_taskGetSource(JNIEnv* env , jclass cls, jobject jtask) { +JNIEXPORT jobject JNICALL +Java_simgrid_msg_MsgNative_taskGetSource(JNIEnv * env, jclass cls, + jobject jtask) +{ m_host_t host; - m_task_t task = jtask_to_native_task(jtask,env); + m_task_t task = jtask_to_native_task(jtask, env); - if(!task){ - jxbt_throw_notbound(env,"task",jtask); + if (!task) { + jxbt_throw_notbound(env, "task", jtask); return NULL; } - + host = MSG_task_get_source(task); - if(! host->data) { - jxbt_throw_native(env, xbt_strdup("MSG_task_get_source() failed")); + if (!host->data) { + jxbt_throw_jni(env, "MSG_task_get_source() failed"); return NULL; } - - return (jobject)host->data; -} - -JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_parallelTaskGetSource(JNIEnv* env , jclass cls, jobject jtask) { - m_task_t task = jparallel_task_to_native_parallel_task(jtask,env); - m_host_t host; - if(!task){ - jxbt_throw_notbound(env,"task",jtask); - return NULL; - } - - host = MSG_task_get_source(task); - - if(! host->data ) { - jxbt_throw_native(env, xbt_strdup("MSG_task_get_source() failed")); - return NULL; - } - - return (jobject)host->data; + return (jobject) host->data; } -JNIEXPORT jstring JNICALL -Java_simgrid_msg_Msg_taskGetName(JNIEnv* env, jclass cls, jobject jtask) { - m_task_t task = jtask_to_native_task(jtask,env); +JNIEXPORT jstring JNICALL +Java_simgrid_msg_MsgNative_taskGetName(JNIEnv * env, jclass cls, + jobject jtask) +{ + m_task_t task = jtask_to_native_task(jtask, env); - if(!task){ - jxbt_throw_notbound(env,"task",jtask); + if (!task) { + jxbt_throw_notbound(env, "task", jtask); return NULL; } - return (*env)->NewStringUTF(env,task->name); + return (*env)->NewStringUTF(env, task->name); } -JNIEXPORT jstring JNICALL -Java_simgrid_msg_Msg_parallelTaskGetName(JNIEnv* env, jclass cls, jobject jtask) { - m_task_t ptask = jparallel_task_to_native_parallel_task(jtask,env); - - if(!ptask){ - jxbt_throw_notbound(env,"task",jtask); - return NULL; - } - - return (*env)->NewStringUTF(env,ptask->name); -} +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_taskCancel(JNIEnv * env, jclass cls, jobject jtask) +{ + m_task_t ptask = jtask_to_native_task(jtask, env); -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_taskCancel(JNIEnv* env, jclass cls, jobject jtask) { - m_task_t ptask = jtask_to_native_task(jtask,env); - - if(!ptask){ - jxbt_throw_notbound(env,"task",jtask); + if (!ptask) { + jxbt_throw_notbound(env, "task", jtask); return; } - - if(MSG_OK != MSG_task_cancel(ptask)) - jxbt_throw_native(env, xbt_strdup("MSG_task_cancel() failed")); -} - -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_parallelTaskCancel(JNIEnv* env, jclass cls, jobject jtask) { - m_task_t ptask = jparallel_task_to_native_parallel_task(jtask,env); - if(!ptask){ - jxbt_throw_notbound(env,"task",jtask); - return; - } - - if(MSG_OK != MSG_task_cancel(ptask)) - jxbt_throw_native(env, xbt_strdup("MSG_task_cancel() failed")); + 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 jdouble JNICALL +Java_simgrid_msg_MsgNative_taskGetComputeDuration(JNIEnv * env, jclass cls, + jobject jtask) +{ + m_task_t ptask = jtask_to_native_task(jtask, env); -JNIEXPORT jdouble JNICALL -Java_simgrid_msg_Msg_taskGetComputeDuration(JNIEnv* env, jclass cls, jobject jtask) { - m_task_t ptask = jtask_to_native_task(jtask,env); - - if(!ptask){ - jxbt_throw_notbound(env,"task",jtask); + if (!ptask) { + jxbt_throw_notbound(env, "task", jtask); return -1; } - return (jdouble)MSG_task_get_compute_duration(ptask); + return (jdouble) MSG_task_get_compute_duration(ptask); } -JNIEXPORT jdouble JNICALL -Java_simgrid_msg_Msg_parallelTaskGetComputeDuration(JNIEnv* env, jclass cls, jobject jtask) { - m_task_t ptask = jparallel_task_to_native_parallel_task(jtask,env); +JNIEXPORT jdouble JNICALL +Java_simgrid_msg_MsgNative_taskGetRemainingDuration(JNIEnv * env, jclass cls, + jobject jtask) +{ + m_task_t ptask = jtask_to_native_task(jtask, env); - if(!ptask){ - jxbt_throw_notbound(env,"task",jtask); + if (!ptask) { + jxbt_throw_notbound(env, "task", jtask); return -1; } - return (jdouble)MSG_task_get_compute_duration(ptask); + return (jdouble) MSG_task_get_remaining_computation(ptask); } -JNIEXPORT jdouble JNICALL -Java_simgrid_msg_Msg_taskGetRemainingDuration(JNIEnv* env, jclass cls, jobject jtask) { - m_task_t ptask = jtask_to_native_task(jtask,env); +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_taskSetPriority(JNIEnv * env, jclass cls, + jobject jtask, jdouble priority) +{ + m_task_t task = jtask_to_native_task(jtask, env); - if(!ptask){ - jxbt_throw_notbound(env,"task",jtask); - return -1; + if (!task) { + jxbt_throw_notbound(env, "task", jtask); + return; } - return (jdouble)MSG_task_get_remaining_computation(ptask); + MSG_task_set_priority(task, (double) priority); } -JNIEXPORT jdouble JNICALL -Java_simgrid_msg_Msg_paralleTaskGetRemainingDuration(JNIEnv* env, jclass cls, jobject jtask) { - m_task_t ptask = jparallel_task_to_native_parallel_task(jtask,env); +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_taskDestroy(JNIEnv * env, jclass cls, + jobject jtask_arg) +{ - if(!ptask){ - jxbt_throw_notbound(env,"task",jtask); - return -1; + /* get the native task */ + m_task_t task = jtask_to_native_task(jtask_arg, env); + jobject jtask; + + if (!task) { + jxbt_throw_notbound(env, "task", task); + return; } - return (jdouble)MSG_task_get_remaining_computation(ptask); + jtask = (jobject) task->data; + + MSG_error_t rv = MSG_task_destroy(task); + + jxbt_check_res("MSG_task_destroy()",rv,MSG_OK, + bprintf("unexpected error , please report this bug")); + + + /* delete the global reference to the java task object */ + jtask_delete_global_ref(jtask, env); } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_taskSetPriority(JNIEnv* env, jclass cls, jobject jtask, jdouble priority) { - m_task_t task = jtask_to_native_task(jtask,env); +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_taskExecute(JNIEnv * env, jclass cls, + jobject jtask) +{ + m_task_t task = jtask_to_native_task(jtask, env); - if(!task){ - jxbt_throw_notbound(env,"task",jtask); + if (!task) { + jxbt_throw_notbound(env, "task", jtask); return; } - MSG_task_set_priority(task,(double)priority); + + MSG_error_t rv = MSG_task_execute(task); + + jxbt_check_res("MSG_task_execute()",rv,MSG_HOST_FAILURE|MSG_TASK_CANCELLED, + bprintf("while executing task %s", MSG_task_get_name(task))); } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_parallelTaskSetPriority(JNIEnv* env, jclass cls, - jobject jtask, jdouble priority) { - m_task_t ptask = jparallel_task_to_native_parallel_task(jtask,env); +/*************************************************************************************** + * Unsortable functions * + ***************************************************************************************/ - if(!ptask){ - jxbt_throw_notbound(env,"task",jtask); - return; - } - MSG_task_set_priority(ptask,(double)priority); + +JNIEXPORT jint JNICALL +Java_simgrid_msg_Msg_getErrCode(JNIEnv * env, jclass cls) +{ + return (jint) MSG_get_errno(); } +JNIEXPORT jdouble JNICALL +Java_simgrid_msg_Msg_getClock(JNIEnv * env, jclass cls) +{ + return (jdouble) MSG_get_clock(); +} -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_taskDestroy(JNIEnv* env, jclass cls, jobject jtask_arg) { - /* get the native task */ - m_task_t task = jtask_to_native_task(jtask_arg,env); - jobject jtask; +JNIEXPORT void JNICALL +Java_simgrid_msg_Msg_init(JNIEnv * env, jclass cls, jobjectArray jargs) { + char **argv = NULL; + int index; + int argc = 0; + jstring jval; + const char *tmp; - if(!task){ - jxbt_throw_notbound(env,"task",jtask); - return; + if (jargs) + argc = (int) (*env)->GetArrayLength(env, jargs); + + argc++; + argv = xbt_new0(char *, argc); + argv[0] = strdup("java"); + + for (index = 0; index < argc - 1; index++) { + jval = (jstring) (*env)->GetObjectArrayElement(env, jargs, index); + tmp = (*env)->GetStringUTFChars(env, jval, 0); + argv[index + 1] = strdup(tmp); + (*env)->ReleaseStringUTFChars(env, jval, tmp); } - jtask = (jobject)task->data; - if(MSG_OK != MSG_task_destroy(task)) - jxbt_throw_native(env, xbt_strdup("MSG_task_destroy() failed")); + MSG_global_init(&argc, argv); + SIMIX_context_select_factory("java"); - /* delete the global reference to the java task object */ - jtask_delete_global_ref(jtask,env); + for (index = 0; index < argc; index++) + free(argv[index]); + + free(argv); + + (*env)->GetJavaVM(env, &__java_vm); } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_parallelTaskDestroy(JNIEnv* env, jclass cls, jobject jtask) { - m_task_t ptask = jparallel_task_to_native_parallel_task(jtask,env); +JNIEXPORT void JNICALL + JNICALL Java_simgrid_msg_Msg_run(JNIEnv * env, jclass cls) { + xbt_fifo_item_t item = NULL; + m_host_t host = NULL; + jobject jhost; - if(!ptask){ - jxbt_throw_notbound(env,"task",jtask); - return; + /* Run everything */ + if (MSG_OK != MSG_main()) { + jxbt_throw_native(env, xbt_strdup("MSG_main() failed")); } - - /* unbind jobj & native one */ - jparallel_task_bind(jtask,0,env); + DEBUG0 + ("MSG_main finished. Bail out before cleanup since there is a bug in this part."); - /* delete the global reference to the java parallel task object */ - jparallel_task_unref(env,jtask); + DEBUG0("Clean java world"); + /* Cleanup java hosts */ + xbt_fifo_foreach(msg_global->host, item, host, m_host_t) { + jhost = (jobject) host->data; - /* free allocated memory */ - if(ptask->simdata->comm_amount) - free(ptask->simdata->comm_amount); + if (jhost) + jhost_unref(env, jhost); + } - if(ptask->simdata->host_list) - free(ptask->simdata->host_list); + DEBUG0("Clean native world"); + /* cleanup native stuff */ + if (MSG_OK != MSG_clean()){ + jxbt_throw_native(env, xbt_strdup("MSG_main() failed")); + } +} - if(MSG_OK != MSG_task_destroy(ptask)) - jxbt_throw_native(env, xbt_strdup("MSG_task_destroy() failed")); +JNIEXPORT jint JNICALL +Java_simgrid_msg_MsgNative_processKillAll(JNIEnv * env, jclass cls, + jint jresetPID) +{ + return (jint) MSG_process_killall((int) jresetPID); } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_taskExecute(JNIEnv* env, jclass cls, jobject jtask) { - m_task_t task = jtask_to_native_task(jtask,env); +JNIEXPORT void JNICALL +Java_simgrid_msg_Msg_createEnvironment(JNIEnv * env, jclass cls, + jstring jplatformFile) +{ - if(!task){ - jxbt_throw_notbound(env,"task",jtask); - return; - } + const char *platformFile = (*env)->GetStringUTFChars(env, jplatformFile, 0); - if(MSG_OK != MSG_task_execute(task)) - jxbt_throw_native(env, xbt_strdup("MSG_task_execute() failed")); + MSG_create_environment(platformFile); + + (*env)->ReleaseStringUTFChars(env, jplatformFile, platformFile); } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_parallelTaskExecute(JNIEnv* env, jclass cls, jobject jtask) { - m_task_t ptask = jparallel_task_to_native_parallel_task(jtask,env); +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_processExit(JNIEnv * env, jclass cls, + jobject jprocess) +{ + + m_process_t process = jprocess_to_native_process(jprocess, env); - if(!ptask){ - jxbt_throw_notbound(env,"task",jtask); + if (!process) { + jxbt_throw_notbound(env, "process", jprocess); return; } - - if(MSG_OK != MSG_parallel_task_execute(ptask)) - jxbt_throw_native(env, xbt_strdup("MSG_parallel_task_execute() failed")); -} - -/*************************************************************************************** - * The MSG channel connected functions implementation. * - ***************************************************************************************/ -JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_channelGet(JNIEnv* env, jclass cls, jobject jchannel) { - m_task_t task = NULL; - - if(MSG_OK != MSG_task_get(&task,(int)jchannel_get_id(jchannel,env))) { - jxbt_throw_native(env, xbt_strdup("MSG_task_get() failed")); - return NULL; - } - - return (jobject)task->data; + SIMIX_context_stop(SIMIX_process_self()->context); } -JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_channelGetWithTimeout(JNIEnv* env, jclass cls, - jobject jchannel, jdouble jtimeout) { - m_task_t task = NULL; - int id = (int)jchannel_get_id(jchannel,env); - - if(MSG_OK != MSG_task_get_with_time_out(&task,id,(double)jtimeout)) { - jxbt_throw_native(env, xbt_strdup("MSG_task_get_with_time_out() failed")); - return NULL; - } - - return (jobject)task->data; +JNIEXPORT void JNICALL +Java_simgrid_msg_Msg_info(JNIEnv * env, jclass cls, jstring js) +{ + const char *s = (*env)->GetStringUTFChars(env, js, 0); + INFO1("%s", s); + (*env)->ReleaseStringUTFChars(env, js, s); } -JNIEXPORT jobject JNICALL -Java_simgrid_msg_Msg_channelGetFromHost(JNIEnv* env, jclass cls, - jobject jchannel, jobject jhost) { - m_host_t host = jhost_get_native(env,jhost); - m_task_t task = NULL; - int id = (int)jchannel_get_id(jchannel,env); +JNIEXPORT jobjectArray JNICALL +Java_simgrid_msg_MsgNative_allHosts(JNIEnv * env, jclass cls_arg) +{ + int index; + jobjectArray jtable; + jobject jhost; + jstring jname; + m_host_t host; - if(!host){ - jxbt_throw_notbound(env,"host",jhost); - return NULL; - } - if(MSG_OK != MSG_task_get_from_host(&task,id,host)){ - jxbt_throw_native(env, xbt_strdup("MSG_task_get_from_host() failed")); + int count = xbt_fifo_size(msg_global->host); + m_host_t *table = (m_host_t *) xbt_fifo_to_array(msg_global->host); + + jclass cls = jxbt_get_class(env, "simgrid/msg/Host"); + + if (!cls) { return NULL; } - if(!(task->data)){ - jxbt_throw_notbound(env,"task",task); + + jtable = (*env)->NewObjectArray(env, (jsize) count, cls, NULL); + + if (!jtable) { + jxbt_throw_jni(env, "Hosts table allocation failed"); return NULL; } - return (jobject)task->data; -} - -JNIEXPORT jboolean JNICALL -Java_simgrid_msg_Msg_channelHasPendingCommunication(JNIEnv* env, jclass cls, jobject jchannel) { - int id = (int)jchannel_get_id(jchannel,env); - - return (jboolean)MSG_task_Iprobe(id); -} + for (index = 0; index < count; index++) { + host = table[index]; + jhost = (jobject) (host->data); -JNIEXPORT jint JNICALL -Java_simgrid_msg_Msg_channelGetCommunicatingProcess(JNIEnv* env, jclass cls, jobject jchannel) { - int id =jchannel_get_id(jchannel,env); - - return (jint)MSG_task_probe_from(id); -} + if (!jhost) { + jname = (*env)->NewStringUTF(env, host->name); -JNIEXPORT jint JNICALL -Java_simgrid_msg_Msg_channelGetHostWaitingTasks(JNIEnv* env, jclass cls, - jobject jchannel, jobject jhost) { - int id = (int)jchannel_get_id(jchannel,env); - m_host_t host = jhost_get_native(env,jhost); + jhost = Java_simgrid_msg_MsgNative_hostGetByName(env, cls_arg, jname); + /* FIXME: leak of jname ? */ + } - if(!host){ - jxbt_throw_notbound(env,"host",jhost); - return -1; + (*env)->SetObjectArrayElement(env, jtable, index, jhost); } - return (jint)MSG_task_probe_from_host(id,host); + return jtable; } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_channelPut(JNIEnv* env, jclass cls, - jobject jchannel, jobject jtask, jobject jhost) { - if(MSG_OK != MSG_task_put(jtask_to_native_task(jtask,env), - jhost_get_native(env,jhost), - (int)jchannel_get_id(jchannel,env))) - jxbt_throw_native(env, xbt_strdup("MSG_task_put() failed")); -} +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_selectContextFactory(JNIEnv * env, jclass class, + jstring jname) +{ + char *errmsg = NULL; + xbt_ex_t e; -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_channelPutWithTimeout(JNIEnv* env, jclass cls, - jobject jchannel, jobject jtask, jobject jhost, - jdouble jtimeout) { - m_task_t task = jtask_to_native_task(jtask,env); - int id = (int)jchannel_get_id(jchannel,env); - m_host_t host = jhost_get_native(env,jhost); + /* get the C string from the java string */ + const char *name = (*env)->GetStringUTFChars(env, jname, 0); - if(!host){ - jxbt_throw_notbound(env,"host",jhost); - return; + TRY { + SIMIX_context_select_factory(name); + } CATCH(e) { + errmsg = xbt_strdup(e.msg); + xbt_ex_free(e); } - if(!task){ - jxbt_throw_notbound(env,"task",jtask); - return; + + (*env)->ReleaseStringUTFChars(env, jname, name); + + if (errmsg) { + char *thrown = bprintf("xbt_select_context_factory() failed: %s", errmsg); + free(errmsg); + jxbt_throw_native(env, thrown); } - - if(MSG_OK != MSG_task_put_with_timeout(task,host,id,(double)jtimeout)) - jxbt_throw_native(env, xbt_strdup("MSG_task_put_with_timeout() failed")); } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_channelPutBounded(JNIEnv* env, jclass cls, - jobject jchannel, jobject jtask, jobject jhost, - jdouble jmaxRate) { - m_task_t task = jtask_to_native_task(jtask,env); - int id = (int)jchannel_get_id(jchannel,env); - m_host_t host = jhost_get_native(env,jhost); +JNIEXPORT void JNICALL +Java_simgrid_msg_MsgNative_taskSend(JNIEnv * env, jclass cls, + jstring jalias, jobject jtask, + 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(!host){ - jxbt_throw_notbound(env,"host",jhost); + + if (!task) { + (*env)->ReleaseStringUTFChars(env, jalias, alias); + jxbt_throw_notbound(env, "task", jtask); return; } - if(!task){ - jxbt_throw_notbound(env,"task",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_simgrid_msg_MsgNative_taskSendBounded(JNIEnv * env, jclass cls, + jstring jalias, jobject jtask, + 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; } - - if(MSG_OK != MSG_task_put_bounded(task,host,id,(double)jmaxRate)) - jxbt_throw_native(env, xbt_strdup("MSG_task_put_bounded() failed")); + + alias = (*env)->GetStringUTFChars(env, jalias, 0); + + 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 jint JNICALL -Java_simgrid_msg_Msg_channelWait(JNIEnv* env, jclass cls, jobject jchannel, jdouble timeout) { - int PID; - int id = (int)jchannel_get_id(jchannel,env); - - if(MSG_OK != MSG_channel_select_from(id,(double)timeout,&PID)) { - jxbt_throw_native(env, xbt_strdup("MSG_channel_select_from() failed")); - return 0; +JNIEXPORT jobject JNICALL +Java_simgrid_msg_MsgNative_taskReceive(JNIEnv * env, jclass cls, + jstring jalias, jdouble jtimeout, + jobject jhost) +{ + MSG_error_t rv; + m_task_t task = NULL; + m_host_t host = NULL; + const char *alias; + + if (jhost) { + host = jhost_get_native(env, jhost); + + if (!host) { + jxbt_throw_notbound(env, "host", jhost); + return NULL; + } } - - return (jint)PID; -} -JNIEXPORT jint JNICALL -Java_simgrid_msg_Msg_channelGetNumber(JNIEnv* env, jclass cls) { - return (jint)MSG_get_channel_number(); -} + alias = (*env)->GetStringUTFChars(env, jalias, 0); -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_channelSetNumber(JNIEnv* env , jclass cls,jint channelNumber) { - MSG_set_channel_number((int)channelNumber); -} + rv = MSG_task_receive_ext(&task, alias, (double) jtimeout, host); -JNIEXPORT jint JNICALL -Java_simgrid_msg_Msg_getErrCode(JNIEnv* env, jclass cls) { - return (jint)MSG_get_errno(); -} + (*env)->ReleaseStringUTFChars(env, jalias, alias); -JNIEXPORT jdouble JNICALL -Java_simgrid_msg_Msg_getClock(JNIEnv* env, jclass cls) { - return (jdouble)MSG_get_clock(); + 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) task->data; } +JNIEXPORT jboolean JNICALL +Java_simgrid_msg_MsgNative_taskListen(JNIEnv * env, jclass cls, + jstring jalias) +{ -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_init(JNIEnv* env, jclass cls, jobjectArray jargs) { - - char** argv = NULL; - int index; - int argc = 0; - jstring jval; - const char* tmp; - - if(jargs) - argc = (int)(*env)->GetArrayLength(env,jargs); + const char *alias; + int rv; - argc++; - - argv = (char**)calloc(argc,sizeof(char*)); - - argv[0] = strdup("java"); - - for(index = 0; index < argc -1; index++) { - jval = (jstring)(*env)->GetObjectArrayElement(env,jargs,index); - - tmp = (*env)->GetStringUTFChars(env, jval, 0); - - argv[index +1] = strdup(tmp); + alias = (*env)->GetStringUTFChars(env, jalias, 0); - (*env)->ReleaseStringUTFChars(env, jval, tmp); - } - - MSG_global_init(&argc,argv); + rv = MSG_task_listen(alias); - for(index = 0; index < argc; index++) - free(argv[index]); - - free(argv); + (*env)->ReleaseStringUTFChars(env, jalias, alias); -#ifdef WIN32 - __current_thread_id = GetCurrentThreadId(); -#else - __current_thread_id = pthread_self(); -#endif - + return (jboolean) rv; } -JNIEXPORT void JNICALL -JNICALL Java_simgrid_msg_Msg_run(JNIEnv* env, jclass cls) { - xbt_fifo_item_t item = NULL; - m_host_t host = NULL; - jobject jhost; +JNIEXPORT jint JNICALL +Java_simgrid_msg_MsgNative_taskListenFromHost(JNIEnv * env, jclass cls, + jstring jalias, jobject jhost) +{ + int rv; + const char *alias; - /* Run everything */ - if(MSG_OK != MSG_main()) - jxbt_throw_native(env, xbt_strdup("MSG_main() failed")); + m_host_t host = jhost_get_native(env, jhost); - DEBUG0("MSG_main finished. Bail out before cleanup since there is a bug in this part."); - SIMIX_display_process_status(); - exit(0); /* FIXME */ - - DEBUG0("Clean java world"); - /* Cleanup java hosts */ - xbt_fifo_foreach(msg_global->host,item,host,m_host_t) { - jhost = (jobject)host->data; - - if(jhost) - jhost_unref(env,jhost); + if (!host) { + jxbt_throw_notbound(env, "host", jhost); + return -1; } - DEBUG0("Clean native world"); - /* cleanup native stuff */ - if(MSG_OK != MSG_clean()) - jxbt_throw_native(env, xbt_strdup("MSG_main() failed")); + alias = (*env)->GetStringUTFChars(env, jalias, 0); -} + rv = MSG_task_listen_from_host(alias, host); -JNIEXPORT jint JNICALL -Java_simgrid_msg_Msg_processKillAll(JNIEnv* env, jclass cls, jint jresetPID) { - return (jint)MSG_process_killall((int)jresetPID); -} + (*env)->ReleaseStringUTFChars(env, jalias, alias); -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_createEnvironment(JNIEnv* env, jclass cls,jstring jplatformFile) { - - const char* platformFile = (*env)->GetStringUTFChars(env, jplatformFile, 0); - - MSG_create_environment(platformFile); - - (*env)->ReleaseStringUTFChars(env, jplatformFile, platformFile); + return (jint) rv; } -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_waitSignal(JNIEnv* env, jclass cls, jobject jprocess) { - m_process_t m_process = jprocess_to_native_process(jprocess,env); - smx_process_t s_process; +JNIEXPORT jint JNICALL +Java_simgrid_msg_MsgNative_taskListenFrom(JNIEnv * env, jclass cls, + jstring jalias) +{ - xbt_os_mutex_t ctx_mutex, creation_mutex; - xbt_os_cond_t ctx_cond, creation_cond; + int rv; + const char *alias = (*env)->GetStringUTFChars(env, jalias, 0); - DEBUG3("Msg_waitSignal(m_process=%p %s/%s)", - m_process,m_process->name,m_process->simdata->m_host->name); - if (!m_process){ - jxbt_throw_notbound(env,"process",jprocess); - return; - } + rv = MSG_task_listen_from(alias); - s_process = m_process->simdata->s_process; + (*env)->ReleaseStringUTFChars(env, jalias, alias); - if (s_process == NULL) { - jxbt_throw_notbound(env,"SIMIX process",jprocess); - return; - } + return (jint) rv; +} - ctx_mutex = SIMIX_process_get_jmutex(s_process); - ctx_cond = SIMIX_process_get_jcond(s_process); +JNIEXPORT void JNICALL +Java_simgrid_msg_Msg_deployApplication(JNIEnv * env, jclass cls, + jstring jdeploymentFile) +{ - creation_mutex = xbt_creation_mutex_get(); - creation_cond = xbt_creation_cond_get(); + const char *deploymentFile = + (*env)->GetStringUTFChars(env, jdeploymentFile, 0); - xbt_os_mutex_lock(creation_mutex); - xbt_os_mutex_lock(ctx_mutex); - xbt_os_cond_signal( creation_cond ); - xbt_os_mutex_unlock( creation_mutex ); - xbt_os_cond_wait(ctx_cond, ctx_mutex); - xbt_os_mutex_unlock(ctx_mutex); -} + surf_parse_reset_parser(); -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_processExit(JNIEnv* env, jclass cls, jobject jprocess) { - m_process_t process = jprocess_to_native_process(jprocess,env); + surfxml_add_callback(STag_surfxml_process_cb_list, + japplication_handler_on_begin_process); - if (!process){ - jxbt_throw_notbound(env,"process",jprocess); - return; - } - MSG_process_kill(process); -} + surfxml_add_callback(ETag_surfxml_argument_cb_list, + japplication_handler_on_process_arg); -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_pajeOutput(JNIEnv* env, jclass cls, jstring jpajeFile) { - const char*pajeFile = (*env)->GetStringUTFChars(env, jpajeFile, 0); - - MSG_paje_output(pajeFile); - - (*env)->ReleaseStringUTFChars(env, jpajeFile, pajeFile); -} + surfxml_add_callback(STag_surfxml_prop_cb_list, + japplication_handler_on_property); + surfxml_add_callback(ETag_surfxml_process_cb_list, + japplication_handler_on_end_process); -JNIEXPORT void JNICALL -Java_simgrid_msg_Msg_info(JNIEnv * env, jclass cls, jstring js) { - const char* s = (*env)->GetStringUTFChars(env,js,0); - INFO1("%s",s); - (*env)->ReleaseStringUTFChars(env, js, s); -} + surf_parse_open(deploymentFile); -JNIEXPORT jobjectArray JNICALL -Java_simgrid_msg_Msg_allHosts(JNIEnv * env, jclass cls_arg) { - int index; - jobjectArray jtable; - jobject jhost; - jstring jname; - m_host_t host; + japplication_handler_on_start_document(); - int count = xbt_fifo_size(msg_global->host); - m_host_t* table = (m_host_t *)xbt_fifo_to_array(msg_global->host); - - jclass cls = jxbt_get_class(env,"simgrid/msg/Host"); - - if(!cls){ - return NULL; - } + if (surf_parse()) + jxbt_throw_native(env, xbt_strdup("surf_parse() failed")); - jtable = (*env)->NewObjectArray(env,(jsize)count,cls,NULL); - - if(!jtable) { - jxbt_throw_jni(env,"Hosts table allocation failed"); - return NULL; - } - - for(index = 0; index < count; index++) { - host = table[index]; - jhost = (jobject)(host->data); - - if(!jhost) { - jname = (*env)->NewStringUTF(env,host->name); - - jhost = Java_simgrid_msg_Msg_hostGetByName(env,cls_arg,jname); - /* FIXME: leak of jname ? */ - } - - (*env)->SetObjectArrayElement(env, jtable, index, jhost); - } + surf_parse_close(); - return jtable; -} + japplication_handler_on_end_document(); - + (*env)->ReleaseStringUTFChars(env, jdeploymentFile, deploymentFile); +}