*/
#include "msg/msg.h"
#include "msg/private.h"
-#include "java/jxbt_context.h"
+#include "simix/private.h"
+#include "xbt/xbt_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 "jxbt_utilities.h"
-XBT_LOG_NEW_DEFAULT_CATEGORY(jmsg,"MSG for Java(TM)");
+#include "jmsg.h"
-/* header for windows */
-#ifdef WIN32
-#include <windows.h>
-#else
-#include <pthread.h>
-#endif
+#include "msg/mailbox.h"
-#include "jmsg.h"
+XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
+static JavaVM * __java_vm = NULL;
-#ifdef WIN32
- static DWORD __current_thread_id = 0;
+static jobject
+native_to_java_process(m_process_t process);
- int is_main_thread() {
- return (GetCurrentThreadId() == __current_thread_id);
- }
+JavaVM *
+get_java_VM(void) {
+ return __java_vm;
+}
-#else /* !WIN32 */
+JNIEnv *
+get_current_thread_env(void) {
+ JNIEnv *env;
- static pthread_t __current_thread_id = 0;
+ (*__java_vm)->AttachCurrentThread(__java_vm, (void **)&env, NULL);
- int is_main_thread() {
- return (pthread_self() == __current_thread_id);
- }
-#endif
+ return env;
+}
+
+static jobject
+native_to_java_process(m_process_t process)
+{
+ return ((xbt_ctx_java_t)(process->simdata->s_process->simdata->context))->jprocess;
+}
/*
*/
JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_processCreate(JNIEnv* env, jclass cls, jobject jprocess_arg, jobject jhost) {
+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_Msg_processCreate(env=%p,cls=%p,jproc=%p,jhost=%p)",
+ 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);
return;
}
- /* bind the java process instance to the native host */
+ /* bind the java process instance to the native process */
jprocess_bind(jprocess,process,env);
/* build the C name of the process */
(*env)->ReleaseStringUTFChars(env, jname, name);
process->simdata->m_host = jhost_get_native(env,jhost);
+
+
if( ! (process->simdata->m_host) ) { /* not binded */
free(process->simdata);
free(process->data);
env);
SIMIX_jprocess_create(process->name,
- process->simdata->m_host->simdata->s_host,
+ process->simdata->m_host->simdata->smx_host,
/*data*/ (void*)process,
- jprocess_arg,env,
- __MSG_process_cleanup,
+ jprocess,env,
&process->simdata->s_process);
+
+
DEBUG1("context created (s_process=%p)",process->simdata->s_process);
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);
+
+ sprintf(alias,"%s:%s",(process->simdata->m_host->simdata->smx_host)->name,process->name);
+
+ mailbox = MSG_mailbox_new(alias);
+ MSG_mailbox_set_hostname(mailbox, process->simdata->m_host->simdata->smx_host->name);
+
- /* 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
}
JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_processSuspend(JNIEnv* env, jclass cls, jobject jprocess) {
+Java_simgrid_msg_MsgNative_processSuspend(JNIEnv* env, jclass cls, jobject jprocess) {
m_process_t process = jprocess_to_native_process(jprocess,env);
if(!process) {
}
JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_processResume(JNIEnv* env, jclass cls, jobject jprocess) {
+Java_simgrid_msg_MsgNative_processResume(JNIEnv* env, jclass cls, jobject jprocess) {
m_process_t process = jprocess_to_native_process(jprocess,env);
if(!process) {
}
JNIEXPORT jboolean JNICALL
-Java_simgrid_msg_Msg_processIsSuspended(JNIEnv* env, jclass cls, jobject jprocess) {
+Java_simgrid_msg_MsgNative_processIsSuspended(JNIEnv* env, jclass cls, jobject jprocess) {
m_process_t process = jprocess_to_native_process(jprocess,env);
if(!process) {
}
JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_processKill(JNIEnv* env, jclass cls, jobject jprocess) {
+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);
}
/* 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)
}
JNIEXPORT jobject JNICALL
-Java_simgrid_msg_Msg_processGetHost(JNIEnv* env, jclass cls, jobject jprocess) {
+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_host_t host;
}
JNIEXPORT jobject JNICALL
-Java_simgrid_msg_Msg_processFromPID(JNIEnv* env, jclass cls, jint PID) {
+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));
+ 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) {
+Java_simgrid_msg_MsgNative_processGetPID(JNIEnv* env, jclass cls, jobject jprocess) {
m_process_t process = jprocess_to_native_process(jprocess,env);
if(!process) {
JNIEXPORT jint JNICALL
-Java_simgrid_msg_Msg_processGetPPID(JNIEnv* env, jclass cls, jobject jprocess) {
+Java_simgrid_msg_MsgNative_processGetPPID(JNIEnv* env, jclass cls, jobject jprocess) {
m_process_t process = jprocess_to_native_process(jprocess,env);
if(!process) {
}
JNIEXPORT jobject JNICALL
-Java_simgrid_msg_Msg_processSelf(JNIEnv* env, jclass cls) {
+Java_simgrid_msg_MsgNative_processSelf(JNIEnv* env, jclass cls) {
m_process_t process = MSG_process_self();
jobject jprocess;
return NULL;
}
- jprocess = SIMIX_process_get_jprocess(process->simdata->s_process);
+ jprocess = native_to_java_process(process);
if(!jprocess)
jxbt_throw_native(env, xbt_strdup("SIMIX_process_get_jprocess() failed"));
JNIEXPORT jint JNICALL
-Java_simgrid_msg_Msg_processSelfPID(JNIEnv* env, jclass cls) {
+Java_simgrid_msg_MsgNative_processSelfPID(JNIEnv* env, jclass cls) {
return (jint)MSG_process_self_PID();
}
JNIEXPORT jint JNICALL
-Java_simgrid_msg_Msg_processSelfPPID(JNIEnv* env, jclass cls) {
+Java_simgrid_msg_MsgNative_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){
+Java_simgrid_msg_MsgNative_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);
}
JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_processWaitFor(JNIEnv* env, jclass cls,jdouble seconds) {
+Java_simgrid_msg_MsgNative_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 jobject JNICALL
-Java_simgrid_msg_Msg_hostGetByName(JNIEnv* env, jclass cls, jstring jname) {
+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 */
}
JNIEXPORT jstring JNICALL
-Java_simgrid_msg_Msg_hostGetName(JNIEnv* env, jclass cls, jobject jhost) {
+Java_simgrid_msg_MsgNative_hostGetName(JNIEnv* env, jclass cls, jobject jhost) {
m_host_t host = jhost_get_native(env,jhost);
if(!host) {
}
JNIEXPORT jint JNICALL
-Java_simgrid_msg_Msg_hostGetNumber(JNIEnv* env, jclass cls) {
+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();
}
JNIEXPORT jdouble JNICALL
-Java_simgrid_msg_Msg_hostGetSpeed(JNIEnv* env, jclass cls, jobject jhost) {
+Java_simgrid_msg_MsgNative_hostGetSpeed(JNIEnv* env, jclass cls, jobject jhost) {
m_host_t host = jhost_get_native(env,jhost);
if(!host) {
}
JNIEXPORT jint JNICALL
-Java_simgrid_msg_Msg_hostGetLoad(JNIEnv* env, jclass cls, jobject jhost) {
+Java_simgrid_msg_MsgNative_hostGetLoad(JNIEnv* env, jclass cls, jobject jhost) {
m_host_t host = jhost_get_native(env,jhost);
if(!host) {
JNIEXPORT jboolean JNICALL
-Java_simgrid_msg_Msg_hostIsAvail(JNIEnv* env, jclass cls, jobject jhost) {
+Java_simgrid_msg_MsgNative_hostIsAvail(JNIEnv* env, jclass cls, jobject jhost) {
m_host_t host = jhost_get_native(env,jhost);
if(!host) {
***************************************************************************************/
JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_taskCreate(JNIEnv* env, jclass cls, jobject jtask, jstring jname,
+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; /* the name of the task */
-
+
if(jcomputeDuration < 0) {
jxbt_throw_illegal(env,bprintf("Task ComputeDuration (%f) cannot be negative",
(double)jcomputeDuration));
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,
+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 */
- jobject jtask; /* the global reference to the java parallel task instance */
int host_count;
m_host_t* hosts;
double* computeDurations;
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));
+ hosts = xbt_new0(m_host_t,host_count);
+ computeDurations = xbt_new0(double,host_count);
+ messageSizes = xbt_new0(double,host_count*host_count);
jcomputeDurations = (*env)->GetDoubleArrayElements(env,jcomputeDurations_arg, 0);
jmessageSizes = (*env)->GetDoubleArrayElements(env,jmessageSizes_arg, 0);
jhost = (*env)->GetObjectArrayElement(env,jhosts,index);
hosts[index] = jhost_get_native(env,jhost);
computeDurations[index] = jcomputeDurations[index];
- messageSizes[index] = jmessageSizes[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)->ReleaseStringUTFChars(env, jname, name);
- /* allocate a new global reference to the java task instance */
- jtask = jparallel_task_ref(env,jtask_arg);
-
/* associate the java task object and the native task */
- jparallel_task_bind(jtask,task,env);
+ jtask_bind(jtask,task,env);
task->data = (void*)jtask;
- if(!(task->data))
+ 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) {
+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);
}
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_parallelTaskGetSender(JNIEnv* env , jclass cls , jobject jtask) {
- m_task_t task;
- m_process_t process;
-
- task = jparallel_task_to_native_parallel_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_taskGetSource(JNIEnv* env , jclass cls, jobject jtask) {
+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);
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;
-}
-
JNIEXPORT jstring JNICALL
-Java_simgrid_msg_Msg_taskGetName(JNIEnv* env, jclass cls, jobject jtask) {
+Java_simgrid_msg_MsgNative_taskGetName(JNIEnv* env, jclass cls, jobject jtask) {
m_task_t task = jtask_to_native_task(jtask,env);
if(!task){
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_Msg_taskCancel(JNIEnv* env, jclass cls, jobject jtask) {
+Java_simgrid_msg_MsgNative_taskCancel(JNIEnv* env, jclass cls, jobject jtask) {
m_task_t ptask = jtask_to_native_task(jtask,env);
if(!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"));
-}
-
-
JNIEXPORT jdouble JNICALL
-Java_simgrid_msg_Msg_taskGetComputeDuration(JNIEnv* env, jclass cls, jobject jtask) {
+Java_simgrid_msg_MsgNative_taskGetComputeDuration(JNIEnv* env, jclass cls, jobject jtask) {
m_task_t ptask = jtask_to_native_task(jtask,env);
if(!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);
-
- if(!ptask){
- jxbt_throw_notbound(env,"task",jtask);
- return -1;
- }
- return (jdouble)MSG_task_get_compute_duration(ptask);
-}
-
-JNIEXPORT jdouble JNICALL
-Java_simgrid_msg_Msg_taskGetRemainingDuration(JNIEnv* env, jclass cls, jobject jtask) {
+Java_simgrid_msg_MsgNative_taskGetRemainingDuration(JNIEnv* env, jclass cls, jobject jtask) {
m_task_t ptask = jtask_to_native_task(jtask,env);
if(!ptask){
return (jdouble)MSG_task_get_remaining_computation(ptask);
}
-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);
-
- if(!ptask){
- jxbt_throw_notbound(env,"task",jtask);
- return -1;
- }
- return (jdouble)MSG_task_get_remaining_computation(ptask);
-}
-
JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_taskSetPriority(JNIEnv* env, jclass cls, jobject jtask, jdouble priority) {
+Java_simgrid_msg_MsgNative_taskSetPriority(JNIEnv* env, jclass cls, jobject jtask, jdouble priority) {
m_task_t task = jtask_to_native_task(jtask,env);
if(!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);
-
- if(!ptask){
- jxbt_throw_notbound(env,"task",jtask);
- return;
- }
- MSG_task_set_priority(ptask,(double)priority);
-}
-
-
-JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_taskDestroy(JNIEnv* env, jclass cls, jobject jtask_arg) {
+Java_simgrid_msg_MsgNative_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;
if(!task){
- jxbt_throw_notbound(env,"task",jtask);
+ jxbt_throw_notbound(env,"task",task);
return;
}
jtask = (jobject)task->data;
}
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);
-
- if(!ptask){
- jxbt_throw_notbound(env,"task",jtask);
- return;
- }
-
- /* unbind jobj & native one */
- jparallel_task_bind(jtask,0,env);
-
- /* delete the global reference to the java parallel task object */
- jparallel_task_unref(env,jtask);
-
- /* free allocated memory */
- if(ptask->simdata->comm_amount)
- free(ptask->simdata->comm_amount);
-
- if(ptask->simdata->host_list)
- free(ptask->simdata->host_list);
-
- if(MSG_OK != MSG_task_destroy(ptask))
- jxbt_throw_native(env, xbt_strdup("MSG_task_destroy() failed"));
-}
-
-JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_taskExecute(JNIEnv* env, jclass cls, jobject jtask) {
+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_native(env, xbt_strdup("MSG_task_execute() failed"));
}
-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);
-
- if(!ptask){
- jxbt_throw_notbound(env,"task",jtask);
- 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. *
+ * The Task reception functions *
***************************************************************************************/
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;
-}
-
-JNIEXPORT jobject JNICALL
-Java_simgrid_msg_Msg_channelGetWithTimeout(JNIEnv* env, jclass cls,
- jobject jchannel, jdouble jtimeout) {
+Java_simgrid_msg_MsgNative_taskGet(JNIEnv* env, jclass cls,
+ jint chan_id, jdouble jtimeout, jobject jhost) {
m_task_t task = NULL;
- int id = (int)jchannel_get_id(jchannel,env);
+ m_host_t host = NULL;
- 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"));
+ if (jhost) {
+ host = jhost_get_native(env,jhost);
+ if(!host){
+ jxbt_throw_notbound(env,"host",jhost);
+ return NULL;
+ }
+ }
+
+ if (MSG_OK != MSG_task_get_ext(&task,(int)chan_id,(double)jtimeout,host)) {
+ jxbt_throw_native(env, xbt_strdup("MSG_task_get_ext() failed"));
return NULL;
}
return (jobject)task->data;
}
-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);
-
- 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"));
- return NULL;
- }
- if(!(task->data)){
- jxbt_throw_notbound(env,"task",task);
- 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);
+Java_simgrid_msg_MsgNative_taskProbe(JNIEnv* env, jclass cls, jint chan_id) {
+ return (jboolean)MSG_task_Iprobe(chan_id);
}
-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);
+JNIEXPORT jobject JNICALL
+Java_simgrid_msg_MsgNative_taskGetCommunicatingProcess(JNIEnv* env, jclass cls, jint chan_id) {
+ int pid = MSG_task_probe_from(chan_id);
+ if (pid>=0)
+ return Java_simgrid_msg_MsgNative_processFromPID(env,cls,(jint)pid);
+
+ return NULL;
}
JNIEXPORT jint JNICALL
-Java_simgrid_msg_Msg_channelGetHostWaitingTasks(JNIEnv* env, jclass cls,
- jobject jchannel, jobject jhost) {
- int id = (int)jchannel_get_id(jchannel,env);
+Java_simgrid_msg_MsgNative_taskProbeHost(JNIEnv* env, jclass cls,
+ jobject jhost, jint chan_id) {
m_host_t host = jhost_get_native(env,jhost);
if(!host){
return -1;
}
- return (jint)MSG_task_probe_from_host(id,host);
+ return (jint)MSG_task_probe_from_host(chan_id,host);
}
-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"));
-}
+/***************************************************************************************
+ * The Task reception functions *
+ ***************************************************************************************/
+
JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_channelPutWithTimeout(JNIEnv* env, jclass cls,
- jobject jchannel, jobject jtask, jobject jhost,
- jdouble jtimeout) {
+Java_simgrid_msg_MsgNative_hostPut(JNIEnv* env, jclass cls,
+ jobject jhost, jint chan_id, jobject jtask,
+ 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);
if(!host){
jxbt_throw_notbound(env,"task",jtask);
return;
}
-
- if(MSG_OK != MSG_task_put_with_timeout(task,host,id,(double)jtimeout))
+
+ if(MSG_OK != MSG_task_put_with_timeout(task,host,(int)chan_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) {
+Java_simgrid_msg_MsgNative_hostPutBounded(JNIEnv* env, jclass cls,
+ jobject jhost, jint chan_id, jobject jtask,
+ 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);
if(!host){
return;
}
- if(MSG_OK != MSG_task_put_bounded(task,host,id,(double)jmaxRate))
+ if(MSG_OK != MSG_task_put_bounded(task,host,(int)chan_id,(double)jmaxRate))
jxbt_throw_native(env, xbt_strdup("MSG_task_put_bounded() failed"));
}
-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;
- }
-
- return (jint)PID;
-}
-
-JNIEXPORT jint JNICALL
-Java_simgrid_msg_Msg_channelGetNumber(JNIEnv* env, jclass cls) {
- return (jint)MSG_get_channel_number();
-}
-
-JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_channelSetNumber(JNIEnv* env , jclass cls,jint channelNumber) {
- MSG_set_channel_number((int)channelNumber);
-}
-
JNIEXPORT jint JNICALL
Java_simgrid_msg_Msg_getErrCode(JNIEnv* env, jclass cls) {
return (jint)MSG_get_errno();
argc++;
- argv = (char**)calloc(argc,sizeof(char*));
+ argv = xbt_new0(char*,1);
argv[0] = strdup("java");
}
MSG_global_init(&argc,argv);
+ MSG_set_channel_number(10); /* FIXME: this should not be fixed statically */
for(index = 0; index < argc; index++)
free(argv[index]);
free(argv);
-#ifdef WIN32
- __current_thread_id = GetCurrentThreadId();
-#else
- __current_thread_id = pthread_self();
-#endif
+ (*env)->GetJavaVM(env,&__java_vm);
}
/* Run everything */
if(MSG_OK != MSG_main())
- jxbt_throw_native(env, xbt_strdup("MSG_main() failed"));
-
+ jxbt_throw_native(env, xbt_strdup("MSG_main() failed"));
+
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);
+ jhost_unref(env,jhost);
}
+
DEBUG0("Clean native world");
/* cleanup native stuff */
if(MSG_OK != MSG_clean())
}
JNIEXPORT jint JNICALL
-Java_simgrid_msg_Msg_processKillAll(JNIEnv* env, jclass cls, jint jresetPID) {
+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_waitSignal(JNIEnv* env, jclass cls, jobject jprocess) {
- m_process_t m_process = jprocess_to_native_process(jprocess,env);
- smx_process_t s_process;
-
- xbt_os_mutex_t ctx_mutex, creation_mutex;
- xbt_os_cond_t ctx_cond, creation_cond;
+Java_simgrid_msg_MsgNative_processExit(JNIEnv* env, jclass cls, jobject jprocess) {
- 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;
- }
-
- s_process = m_process->simdata->s_process;
-
- if (s_process == NULL) {
- jxbt_throw_notbound(env,"SIMIX process",jprocess);
- return;
- }
-
- ctx_mutex = SIMIX_process_get_jmutex(s_process);
- ctx_cond = SIMIX_process_get_jcond(s_process);
-
- creation_mutex = xbt_creation_mutex_get();
- creation_cond = xbt_creation_cond_get();
-
- 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);
-}
-
-JNIEXPORT void JNICALL
-Java_simgrid_msg_Msg_processExit(JNIEnv* env, jclass cls, jobject jprocess) {
m_process_t process = jprocess_to_native_process(jprocess,env);
if (!process){
jxbt_throw_notbound(env,"process",jprocess);
return;
}
- MSG_process_kill(process);
+
+ xbt_context_stop(0);
}
JNIEXPORT void JNICALL
}
JNIEXPORT jobjectArray JNICALL
-Java_simgrid_msg_Msg_allHosts(JNIEnv * env, jclass cls_arg) {
+Java_simgrid_msg_MsgNative_allHosts(JNIEnv * env, jclass cls_arg) {
int index;
jobjectArray jtable;
jobject jhost;
if(!jhost) {
jname = (*env)->NewStringUTF(env,host->name);
- jhost = Java_simgrid_msg_Msg_hostGetByName(env,cls_arg,jname);
+ jhost = Java_simgrid_msg_MsgNative_hostGetByName(env,cls_arg,jname);
/* FIXME: leak of jname ? */
}
return jtable;
}
+
+JNIEXPORT void JNICALL
+Java_simgrid_msg_MsgNative_selectContextFactory(JNIEnv * env, jclass class,jstring jname)
+{
+ char *errmsg = NULL;
+ xbt_ex_t e;
+
+ /* get the C string from the java string*/
+ const char* name = (*env)->GetStringUTFChars(env, jname, 0);
+
+ TRY {
+ xbt_context_select_factory(name);
+ } CATCH(e) {
+ errmsg = xbt_strdup(e.msg);
+ xbt_ex_free(e);
+ }
+
+ (*env)->ReleaseStringUTFChars(env, jname, name);
+
+ if(errmsg) {
+ char *thrown = bprintf("xbt_select_context_factory() failed: %s",errmsg);
+ free(errmsg);
+ jxbt_throw_native(env, thrown);
+ }
+}
+
+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(!task){
+ (*env)->ReleaseStringUTFChars(env, jalias, alias);
+ jxbt_throw_notbound(env,"task",jtask);
+ return;
+ }
+
+ rv = MSG_task_send_with_timeout(task,alias,(double)jtimeout);
+
+ (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+ if(MSG_OK != rv)
+ jxbt_throw_native(env, xbt_strdup("MSG_task_send_with_timeout() failed"));
+
+}
+
+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;
+ }
+
+ alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+ rv = MSG_task_send_bounded(task,alias,(double)jmaxRate);
+
+ (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+ if(MSG_OK != rv)
+ jxbt_throw_native(env, xbt_strdup("MSG_task_send_bounded() failed"));
+}
+
+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;
+ }
+ }
+
+ alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+ rv = MSG_task_receive_ext(&task,alias,(double)jtimeout,host);
+
+ (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+ if (MSG_OK != rv)
+ {
+ jxbt_throw_native(env, xbt_strdup("MSG_task_receive_ext() failed"));
+ return NULL;
+ }
+
+ return (jobject)task->data;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_simgrid_msg_MsgNative_taskListen(JNIEnv* env, jclass cls, jstring jalias) {
+
+ const char* alias;
+ int rv;
+
+ alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+ rv = MSG_task_listen(alias);
+
+ (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+ return (jboolean)rv;
+}
+
+JNIEXPORT jint JNICALL
+Java_simgrid_msg_MsgNative_taskListenFromHost(JNIEnv* env, jclass cls, jstring jalias, jobject jhost) {
+
+ int rv;
+ const char* alias;
+
+ m_host_t host = jhost_get_native(env,jhost);
+
+ if(!host){
+ jxbt_throw_notbound(env,"host",jhost);
+ return -1;
+ }
+
+ alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+ rv = MSG_task_listen_from_host(alias,host);
+
+ (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+ return (jint)rv;
+}
+
+JNIEXPORT jint JNICALL
+Java_simgrid_msg_MsgNative_taskListenFrom(JNIEnv* env, jclass cls, jstring jalias) {
+
+ int rv;
+ const char* alias = (*env)->GetStringUTFChars(env, jalias, 0);
+
+ rv = MSG_task_listen_from(alias);
+
+ (*env)->ReleaseStringUTFChars(env, jalias, alias);
+
+ return (jint)rv;
+}
