X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/2959d30f87f56782d55ac870cd66b0f622a2925c..c1a801890b53e18c22319f0d875db0f75711776f:/org/simgrid/msg/Process.java?ds=sidebyside diff --git a/org/simgrid/msg/Process.java b/org/simgrid/msg/Process.java index 1c85cf0283..10591d3595 100644 --- a/org/simgrid/msg/Process.java +++ b/org/simgrid/msg/Process.java @@ -67,20 +67,46 @@ public abstract class Process extends Thread { */ public long id; - public Hashtable properties; + /** + * + */ + public Hashtable properties; /** * The name of the process. */ protected String name; - public String msgName() { + /** + * The PID of the process + */ + protected int pid = -1; + /** + * The PPID of the process + */ + protected int ppid = -1; + /** + * 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; + /** + * + */ + /** + * + */ + protected Sem schedBegin, schedEnd; + private boolean nativeStop = false; /** * Default constructor (used in ApplicationHandler to initialize it) @@ -120,7 +146,8 @@ public abstract class Process extends Thread { * @param args The arguments of the main function of the process. * * @exception HostNotFoundException if no host with this name exists. - * NativeException + * NativeException + * @throws NativeException * */ public Process(String hostname, String name, String args[]) throws HostNotFoundException, NativeException { @@ -158,7 +185,12 @@ public abstract class Process extends Thread { if (null != args) this.args.addAll(Arrays.asList(args)); - MsgNative.processCreate(this, host); + try { + MsgNative.processCreate(this, host.getName()); + } catch (HostNotFoundException e) { + throw new RuntimeException("The impossible happend (yet again): the host that I have were not found",e); + } + } @@ -177,14 +209,35 @@ public abstract class Process extends Thread { } /** - * This method adds an argument in the list of the arguments of the main function - * of the process. + * 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; + } + /** + * getter for the flag that indicates that this thread must be killed + * + * @return + * + */ + public boolean getNativeStop() + { + return nativeStop; + } + + /** + * This method kill a process. + * @param process the process to be killed. * - * @param arg The argument to add. */ - @Deprecated - protected void addArg(String arg) { - args.add(arg); + public void kill() { + nativeStop(); + Msg.info("Process " + msgName() + " will be killed."); + } /** @@ -218,11 +271,13 @@ public abstract class Process extends Thread { * * @return The host instance of the process. * - * @exception NativeException on error in the native SimGrid code * */ public Host getHost() { - return MsgNative.processGetHost(this); + if (this.host == null) { + this.host = MsgNative.processGetHost(this); + } + return this.host; } /** * This static method gets a process from a PID. @@ -243,7 +298,10 @@ public abstract class Process extends Thread { * */ public int getPID() { - return MsgNative.processGetPID(this); + if (pid == -1) { + pid = MsgNative.processGetPID(this); + } + return pid; } /** * This method returns the PID of the parent of a process. @@ -252,7 +310,10 @@ public abstract class Process extends Thread { * */ public int getPPID() { - return MsgNative.processGetPPID(this); + if (ppid == -1) { + ppid = MsgNative.processGetPPID(this); + } + return ppid; } /** * This static method returns the currently running process. @@ -272,6 +333,7 @@ public abstract class Process extends Thread { */ public static void migrate(Process process, Host host) { MsgNative.processMigrate(process, host); + process.host = null; } /** * Makes the current process sleep until time seconds have elapsed. @@ -283,13 +345,25 @@ public abstract class Process extends Thread { public static void waitFor(double seconds) throws HostFailureException { MsgNative.processWaitFor(seconds); } - public void showArgs() { + /** + * + */ + public void showArgs() { Msg.info("[" + this.name + "/" + this.getHost().getName() + "] argc=" + this.args.size()); for (int i = 0; i < this.args.size(); i++) Msg.info("[" + this.msgName() + "/" + this.getHost().getName() + "] 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 + */ + public native void simulatedSleep(double seconds); + /** * This method runs the process. Il calls the method function that you must overwrite. */ @@ -319,35 +393,130 @@ public abstract class Process extends Thread { Msg.info("Unexpected behavior. Stopping now"); System.exit(1); } + catch(ProcessKilled pk) { + if (nativeStop) { + try { + MsgNative.processExit(this); + } 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 + * so that it does some garbage collecting on its own. When it does so here, + * the Java thread checks when starting if it's supposed to be killed (to inform + * the C world). To avoid the infinite loop or anything similar, we ignore that + * exception now. This should be ok since we ignore only a very specific exception + * class and not a generic (such as any RuntimeException). + */ + System.err.println(currentThread().getName()+": I ignore that other exception"); + } + Msg.info(" Process " + ((Process) Thread.currentThread()).msgName() + " has been killed."); + schedEnd.release(); + } + else { + pk.printStackTrace(); + Msg.info("Unexpected behavior. Stopping now"); + System.exit(1); + } + } } /** * The main function of the process (to implement). - */ + * + * @param args + * @throws MsgException + */ public abstract void main(String[]args) throws MsgException; - public void unschedule() { - try { + /** @brief Gives the control from the given user thread back to the maestro + * + * schedule() and unschedule() are the basis of interactions between the user threads + * (executing the user code), and the maestro thread (executing the platform models to decide + * which user thread should get executed when. Once it decided which user thread should be run + * (because the blocking action it were blocked onto are terminated in the simulated world), the + * maestro passes the control to this uthread by calling uthread.schedule() in the maestro thread + * (check its code for the simple semaphore-based synchronization schema). + * + * The uthread executes (while the maestro is blocked), until it starts another blocking + * action, such as a communication or so. In that case, uthread.unschedule() gets called from + * the user thread. + * + * As other complications, these methods are called directly by the C through a JNI upcall in + * response to the JNI downcalls done by the Java code. For example, you have this (simplified) + * execution path: + * - a process calls the Task.send() method in java + * - this calls Java_org_simgrid_msg_MsgNative_taskSend() in C through JNI + * - this ends up calling jprocess_unschedule(), still in C + * - this calls the java method "org/simgrid/msg/Process/unschedule()V" through JNI + * - that is to say, the unschedule() method that you are reading the documentation of. + * + * To understand all this, you must keep in mind that there is no difference between the C thread + * describing a process, and the Java thread doing the same. Most of the time, they are system + * threads from the kernel anyway. In the other case (such as when using green java threads when + * the OS does not provide any thread feature), I'm unsure of what happens: it's a very long time + * that I didn't see any such OS. + * + * The synchronization itself is implemented using simple semaphores in Java, as you can see by + * checking the code of these functions (and run() above). That's super simple, and thus welcome + * given the global complexity of the synchronization architecture: getting C and Java cooperate + * with regard to thread handling in a portable manner is very uneasy. A simple and straightforward + * implementation of each synchronization point is precious. + * + * But this kinda limits the system scalability. It may reveal difficult to simulate dozens of + * thousands of processes this way, both for memory limitations and for hard limits pushed by the + * system on the amount of threads and semaphores (we have 2 semaphores per user process). + * + * At time of writing, the best source of information on how to simulate large systems within the + * Java bindings of simgrid is here: http://tomp2p.net/dev/simgrid/ + * + */ + public void unschedule() { + /* this function is called from the user thread only */ + try { + + /* unlock the maestro before going to sleep */ schedEnd.release(); + /* Here, the user thread is locked, waiting for the semaphore, and maestro executes instead */ schedBegin.acquire(); - } catch(InterruptedException e) { + /* now that the semaphore is acquired, it means that maestro gave us the control back */ + + /* the user thread is starting again after giving the control to maestro. + * Let's check if we were asked to die in between */ + if ( (Thread.currentThread() instanceof Process) &&((Process) Thread.currentThread()).getNativeStop()) { + throw new ProcessKilled(); + } + + } catch (InterruptedException e) { + /* ignore this exception because this is how we get killed on process.kill or end of simulation. + * I don't like hiding exceptions this way, but fail to see any other solution + */ } + } - public void schedule() { - //System.err.println("Scheduling process in Java"); + /** @brief Gives the control from the maestro back to the given user thread + * + * Must be called from the maestro thread -- see unschedule() for details. + * + */ + public void schedule() { try { + /* unlock the user thread before going to sleep */ schedBegin.release(); + /* Here, maestro is locked, waiting for the schedEnd semaphore to get signaled by used thread, that executes instead */ schedEnd.acquire(); + /* Maestro now has the control back and the user thread went to sleep gently */ + } catch(InterruptedException e) { - System.err.println("Got an interuption while scheduling process in Java"); - e.printStackTrace(); + 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) - * @throws TimeoutException + * @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 { @@ -355,29 +524,59 @@ public abstract class Process extends Thread { } /** Send the given task in the mailbox associated with the specified alias - * @throws TimeoutException + * @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 */ + /** 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) */ + /** 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 */ + /** 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*/ + /** 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); }