X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/9d45f09800ba18cc02555b9d40ad6f5090eaa8a4..7b2435d30a045a0c8c292c0fd98a2a2379a40fb3:/org/simgrid/msg/Process.java diff --git a/org/simgrid/msg/Process.java b/org/simgrid/msg/Process.java index 7289d96123..d9cedd97aa 100644 --- a/org/simgrid/msg/Process.java +++ b/org/simgrid/msg/Process.java @@ -14,6 +14,7 @@ package org.simgrid.msg; import java.util.Arrays; import java.util.Hashtable; import java.util.Vector; +import java.util.concurrent.Semaphore; /** * A process may be defined as a code, with some private data, executing @@ -67,9 +68,6 @@ public abstract class Process extends Thread { */ public long id; - /** - * - */ public Hashtable properties; /** @@ -88,24 +86,14 @@ public abstract class Process extends Thread { * The host of the process */ protected Host host = null; - /** - * - * @return - */ - public String msgName() { - return this.name; - } + /** The arguments of the method function of the process. */ public Vector args; /* process synchronization tools */ - /** - * - */ - /** - * - */ - protected Sem schedBegin, schedEnd; + + /* give the full path to semaphore to ensure that our own implementation don't get selected */ + protected java.util.concurrent.Semaphore schedBegin, schedEnd; private boolean nativeStop = false; /** @@ -118,8 +106,8 @@ public abstract class Process extends Thread { this.bind = 0; this.args = new Vector(); this.properties = null; - schedBegin = new Sem(0); - schedEnd = new Sem(0); + schedBegin = new java.util.concurrent.Semaphore(0); + schedEnd = new java.util.concurrent.Semaphore(0); } @@ -185,11 +173,18 @@ public abstract class Process extends Thread { if (null != args) this.args.addAll(Arrays.asList(args)); - MsgNative.processCreate(this, host); + try { + create(host.getName()); + } catch (HostNotFoundException e) { + throw new RuntimeException("The impossible happened (yet again): the host that I have were not found",e); + } } - - + /** + * The natively implemented method to create an MSG process. + * @param host A valid (binded) host where create the process. + */ + protected native void create(String hostName) throws HostNotFoundException; /** * This method kills all running process of the simulation. * @@ -200,19 +195,15 @@ public abstract class Process extends Thread { * @return The function returns the PID of the next created process. * */ - public static int killAll(int resetPID) { - return MsgNative.processKillAll(resetPID); - } - + public static native int killAll(int resetPID); /** * This method sets a flag to indicate that this thread must be killed. End user must use static method kill * * @return * */ - public void nativeStop() - { - nativeStop = true; + public void nativeStop() { + nativeStop = true; } /** * getter for the flag that indicates that this thread must be killed @@ -220,8 +211,7 @@ public abstract class Process extends Thread { * @return * */ - public boolean getNativeStop() - { + public boolean getNativeStop() { return nativeStop; } @@ -232,8 +222,7 @@ public abstract class Process extends Thread { */ public void kill() { nativeStop(); - Msg.info("Process " + msgName() + " will be killed."); - + Msg.info("Process " + msgName() + " will be killed."); } /** @@ -241,38 +230,32 @@ public abstract class Process extends Thread { * waiting for the completion. * */ - public void pause() { - MsgNative.processSuspend(this); - } + public native void pause(); /** * Resumes a suspended process by resuming the task on which it was * waiting for the completion. * * */ - public void restart() { - MsgNative.processResume(this); - } + public native void restart(); /** * Tests if a process is suspended. * * @return The method returns true if the process is suspended. * Otherwise the method returns false. */ - public boolean isSuspended() { - return MsgNative.processIsSuspended(this); + public native boolean isSuspended(); + /** + * Returns the name of the process + */ + public String msgName() { + return this.name; } /** - * Returns the host of a process. - * + * Returns the host of the process. * @return The host instance of the process. - * - * */ public Host getHost() { - if (this.host == null) { - this.host = MsgNative.processGetHost(this); - } return this.host; } /** @@ -284,9 +267,7 @@ public abstract class Process extends Thread { * * @exception NativeException on error in the native SimGrid code */ - public static Process fromPID(int PID) throws NativeException { - return MsgNative.processFromPID(PID); - } + public static native Process fromPID(int PID) throws NativeException; /** * This method returns the PID of the process. * @@ -294,9 +275,6 @@ public abstract class Process extends Thread { * */ public int getPID() { - if (pid == -1) { - pid = MsgNative.processGetPID(this); - } return pid; } /** @@ -306,9 +284,6 @@ public abstract class Process extends Thread { * */ public int getPPID() { - if (ppid == -1) { - ppid = MsgNative.processGetPPID(this); - } return ppid; } /** @@ -317,9 +292,12 @@ public abstract class Process extends Thread { * @return The current process. * */ - public static Process currentProcess() { - return MsgNative.processSelf(); - } + public static native Process currentProcess(); + /** + * Kills a MSG process + * @param process Valid java process to kill + */ + final static native void kill(Process process); /** * Migrates a process to another host. * @@ -331,17 +309,30 @@ public abstract class Process extends Thread { MsgNative.processMigrate(process, host); process.host = null; } + /** + * Makes the current process sleep until millis millisecondes have elapsed. + * You should note that unlike "waitFor" which takes seconds, this method takes milliseconds. + * FIXME: Not optimal, maybe we should have two native functions. + * @param millis the length of time to sleep in milliseconds. + */ + public static void sleep(long millis) { + sleep(millis,0); + } + /** + * Makes the current process sleep until millis milliseconds and nanos nanoseconds + * have elapsed. + * You should note that unlike "waitFor" which takes seconds, this method takes milliseconds and nanoseconds. + * Overloads Thread.sleep. + * @param millis the length of time to sleep in milliseconds. + * @param nanos additionnal nanoseconds to sleep. + */ + public native static void sleep(long millis, int nanos); /** * Makes the current process sleep until time seconds have elapsed. - * * @param seconds The time the current process must sleep. - * - * @exception HostFailureException on error in the native SimGrid code */ - public static void waitFor(double seconds) throws HostFailureException { - MsgNative.processWaitFor(seconds); - } - /** + public native void waitFor(double seconds); + /** * */ public void showArgs() { @@ -352,20 +343,16 @@ public abstract class Process extends Thread { "] args[" + i + "]=" + (String) (this.args.get(i))); } /** - * Let the simulated process sleep for the given amount of millisecond in the simulated world. - * - * You don't want to use sleep instead, because it would freeze your simulation - * run without any impact on the simulated world. - * @param millis + * Exit the process */ - public native void simulatedSleep(double seconds); + public native void exit(); /** * This method runs the process. Il calls the method function that you must overwrite. */ public void run() { - String[]args = null; /* do not fill it before the signal or this.args will be empty */ + String[] args = null; /* do not fill it before the signal or this.args will be empty */ //waitSignal(); /* wait for other people to fill the process in */ @@ -382,7 +369,7 @@ public abstract class Process extends Thread { } this.main(args); - MsgNative.processExit(this); + exit(); schedEnd.release(); } catch(MsgException e) { e.printStackTrace(); @@ -392,7 +379,7 @@ public abstract class Process extends Thread { catch(ProcessKilled pk) { if (nativeStop) { try { - MsgNative.processExit(this); + exit(); } catch (ProcessKilled pk2) { /* Ignore that other exception that *will* occur all the time. * This is because the C mechanic gives the control to the now-killed process @@ -404,13 +391,13 @@ public abstract class Process extends Thread { */ System.err.println(currentThread().getName()+": I ignore that other exception"); } - Msg.info(" Process " + ((Process) Thread.currentThread()).msgName() + " has been killed."); - schedEnd.release(); + Msg.info(" Process " + ((Process) Thread.currentThread()).msgName() + " has been killed."); + schedEnd.release(); } else { - pk.printStackTrace(); - Msg.info("Unexpected behavior. Stopping now"); - System.exit(1); + pk.printStackTrace(); + Msg.info("Unexpected behavior. Stopping now"); + System.exit(1); } } } @@ -507,73 +494,12 @@ public abstract class Process extends Thread { throw new RuntimeException("The impossible did happend once again: I got interrupted in schedEnd.acquire()",e); } } - - /** Send the given task in the mailbox associated with the specified alias (waiting at most given time) - * @param mailbox - * @param task - * @param timeout - * @throws TimeoutException - * @throws HostFailureException - * @throws TransferFailureException */ - public void taskSend(String mailbox, Task task, double timeout) throws TransferFailureException, HostFailureException, TimeoutException { - MsgNative.taskSend(mailbox, task, timeout); - } - - /** Send the given task in the mailbox associated with the specified alias - * @param mailbox - * @param task - * @throws TimeoutException - * @throws HostFailureException - * @throws TransferFailureException */ - public void taskSend(String mailbox, Task task) throws TransferFailureException, HostFailureException, TimeoutException { - MsgNative.taskSend(mailbox, task, -1); - } - - /** Receive a task on mailbox associated with the specified mailbox - * @param mailbox - * @return - * @throws TransferFailureException - * @throws HostFailureException - * @throws TimeoutException - */ - public Task taskReceive(String mailbox) throws TransferFailureException, HostFailureException, TimeoutException { - return MsgNative.taskReceive(mailbox, -1.0, null); - } - - /** Receive a task on mailbox associated with the specified alias (waiting at most given time) - * @param mailbox - * @param timeout - * @return - * @throws TransferFailureException - * @throws HostFailureException - * @throws TimeoutException - */ - public Task taskReceive(String mailbox, double timeout) throws TransferFailureException, HostFailureException, TimeoutException { - return MsgNative.taskReceive(mailbox, timeout, null); - } - - /** Receive a task on mailbox associated with the specified alias from given sender - * @param mailbox - * @param host - * @param timeout - * @return - * @throws TransferFailureException - * @throws HostFailureException - * @throws TimeoutException - */ - public Task taskReceive(String mailbox, double timeout, Host host) throws TransferFailureException, HostFailureException, TimeoutException { - return MsgNative.taskReceive(mailbox, timeout, host); - } - - /** Receive a task on mailbox associated with the specified alias from given sender - * @param mailbox - * @param host - * @return - * @throws TransferFailureException - * @throws HostFailureException - * @throws TimeoutException - */ - public Task taskReceive(String mailbox, Host host) throws TransferFailureException, HostFailureException, TimeoutException { - return MsgNative.taskReceive(mailbox, -1.0, host); + + /** + * Class initializer, to initialize various JNI stuff + */ + public static native void nativeInit(); + static { + nativeInit(); } }