Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
0a49369fbccc3b218c19e9eb378ab0a17a0aa11d
[simgrid.git] / src / java / simgrid / msg / Process.java
1 /*
2  * $Id$
3  *
4  * Copyright 2006,2007 Martin Quinson, Malek Cherier           
5  * All right reserved. 
6  *
7  * This program is free software; you can redistribute 
8  * it and/or modify it under the terms of the license 
9  *(GNU LGPL) which comes with this package. 
10  */
11
12 package simgrid.msg;
13
14 import java.lang.Thread;
15 import java.util.*;
16
17 /**
18  * A process may be defined as a code, with some private data, executing 
19  * in a location (host). All the process used by your simulation must be
20  * declared in the deployment file (XML format).
21  * To create your own process you must inherit your own process from this 
22  * class and override the method "main()". For example if you want to use 
23  * a process named Slave proceed as it :
24  *
25  * (1) import the class Process of the package simgrid.msg
26  * import simgrid.msg.Process;
27  * 
28  * public class Slave extends simgrid.msg.Process {
29  *
30  *  (2) Override the method function
31  * 
32  *  \verbatim
33  *      public void main(String[] args) {
34  *              System.out.println("Hello MSG");
35  *      }
36  *  \endverbatim
37  * }
38  * The name of your process must be declared in the deployment file of your simulation.
39  * For the example, for the previous process Slave this file must contains a line :
40  * <process host="Maxims" function="Slave"/>, where Maxims is the host of the process
41  * Slave. All the process of your simulation are automatically launched and managed by Msg.
42  * A process use tasks to simulate communications or computations with another process. 
43  * For more information see Task. For more information on host concept 
44  * see Host.
45  * 
46  */
47
48 public abstract class Process extends Thread {
49         /**
50          * This attribute represents a bind between a java process object and
51          * a native process. Even if this attribute is public you must never
52          * access to it. It is set automatically during the build of the object.
53          */
54         public long bind;
55
56         /**
57          * Even if this attribute is public you must never access to it.
58          * It is used to compute the id of an MSG process.
59          */
60         public static long nextProcessId = 0;
61
62         /**
63          * Even if this attribute is public you must never access to it.
64          * It is compute automatically during the creation of the object. 
65          * The native functions use this identifier to synchronize the process.
66          */
67         public long id;
68
69         public Hashtable<String,String> properties;
70
71         /**
72          * The name of the process.                                                     
73          */
74         protected String name;
75         public String msgName() {
76                 return this.name;
77         }
78         /** The arguments of the method function of the process. */     
79         public Vector<String> args;
80
81         /* process synchronization tools */
82         protected Sem schedBegin, schedEnd;
83
84         /**
85          * Default constructor (used in ApplicationHandler to initialize it)
86          */
87         protected Process() {
88                 super();
89                 this.id = nextProcessId++;
90                 this.name = null;
91                 this.bind = 0;
92                 this.args = new Vector<String>();
93                 this.properties = null;
94                 schedBegin = new Sem(0);
95                 schedEnd = new Sem(0);
96         }
97
98
99         /**
100          * Constructs a new process from the name of a host and his name. The method
101          * function of the process doesn't have argument.
102          *
103          * @param hostname              The name of the host of the process to create.
104          * @param name                  The name of the process.
105          *
106          * @exception                   HostNotFoundException  if no host with this name exists.
107          *                      
108          *
109          */
110         public Process(String hostname, String name) throws HostNotFoundException {
111                 this(Host.getByName(hostname), name, null);
112         }
113         /**
114          * Constructs a new process from the name of a host and his name. The arguments
115          * of the method function of the process are specified by the parameter args.
116          *
117          * @param hostname              The name of the host of the process to create.
118          * @param name                  The name of the process.
119          * @param args                  The arguments of the main function of the process.
120          *
121          * @exception                   HostNotFoundException  if no host with this name exists.
122          *                      NativeException
123          *
124          */ 
125         public Process(String hostname, String name, String args[]) throws HostNotFoundException, NativeException {
126                 this(Host.getByName(hostname), name, args);
127         }
128         /**
129          * Constructs a new process from a host and his name. The method function of the 
130          * process doesn't have argument.
131          *
132          * @param host                  The host of the process to create.
133          * @param name                  The name of the process.
134          *
135          */
136         public Process(Host host, String name) {
137                 this(host, name, null);
138         }
139         /**
140          * Constructs a new process from a host and his name, the arguments of here method function are
141          * specified by the parameter args.
142          *
143          * @param host                  The host of the process to create.
144          * @param name                  The name of the process.
145          * @param args                  The arguments of main method of the process.
146          *
147          */
148         public Process(Host host, String name, String[]args) {
149                 /* This is the constructor called by all others */
150                 this();
151                 
152                 if (name == null)
153                         throw new NullPointerException("Process name cannot be NULL");
154                 this.name = name;
155
156                 this.args = new Vector<String>();
157                 if (null != args)
158                         this.args.addAll(Arrays.asList(args));
159
160                 MsgNative.processCreate(this, host);
161         }
162
163
164         /**
165          * This method kills all running process of the simulation.
166          *
167          * @param resetPID              Should we reset the PID numbers. A negative number means no reset
168          *                                              and a positive number will be used to set the PID of the next newly
169          *                                              created process.
170          *
171          * @return                              The function returns the PID of the next created process.
172          *                      
173          */ 
174         public static int killAll(int resetPID) {
175                 return MsgNative.processKillAll(resetPID);
176         }
177
178         /**
179          * This method adds an argument in the list of the arguments of the main function
180          * of the process. 
181          *
182          * @param arg                   The argument to add.
183          */
184         @Deprecated
185         protected void addArg(String arg) {
186                 args.add(arg);
187         }
188
189         /**
190          * Suspends the process by suspending the task on which it was
191          * waiting for the completion.
192          *
193          */
194         public void pause() {
195                 MsgNative.processSuspend(this);
196         }
197         /**
198          * Resumes a suspended process by resuming the task on which it was
199          * waiting for the completion.
200          *
201          *
202          */ 
203         public void restart()  {
204                 MsgNative.processResume(this);
205         }
206         /**
207          * Tests if a process is suspended.
208          *
209          * @return                              The method returns true if the process is suspended.
210          *                                              Otherwise the method returns false.
211          */ 
212         public boolean isSuspended() {
213                 return MsgNative.processIsSuspended(this);
214         }
215         /**
216          * Returns the host of a process.
217          *
218          * @return                              The host instance of the process.
219          *
220          * @exception                   NativeException on error in the native SimGrid code
221          *
222          */ 
223         public Host getHost() {
224                 return MsgNative.processGetHost(this);
225         }
226         /**
227          * This static method gets a process from a PID.
228          *
229          * @param PID                   The process identifier of the process to get.
230          *
231          * @return                              The process with the specified PID.
232          *
233          * @exception                   NativeException on error in the native SimGrid code
234          */ 
235         public static Process fromPID(int PID) throws NativeException {
236                 return MsgNative.processFromPID(PID);
237         }
238         /**
239          * This method returns the PID of the process.
240          *
241          * @return                              The PID of the process.
242          *
243          */ 
244         public int getPID()  {
245                 return MsgNative.processGetPID(this);
246         }
247         /**
248          * This method returns the PID of the parent of a process.
249          *
250          * @return                              The PID of the parent of the process.
251          *
252          */ 
253         public int getPPID()  {
254                 return MsgNative.processGetPPID(this);
255         }
256         /**
257          * This static method returns the currently running process.
258          *
259          * @return                              The current process.
260          *
261          */ 
262         public static Process currentProcess()  {
263                 return MsgNative.processSelf();
264         }
265         /**
266          * Migrates a process to another host.
267          *
268          * @param host                  The host where to migrate the process.
269          *
270          */
271         public void migrate(Host host)  {
272                 MsgNative.processChangeHost(this, host);
273         }
274         /**
275          * Makes the current process sleep until time seconds have elapsed.
276          *
277          * @param seconds               The time the current process must sleep.
278          *
279          * @exception                   HostFailureException on error in the native SimGrid code
280          */ 
281         public static void waitFor(double seconds) throws HostFailureException {
282                 MsgNative.processWaitFor(seconds);
283         } 
284         public void showArgs() {
285                 try {
286                         Msg.info("[" + this.name + "/" + this.getHost().getName() + "] argc=" +
287                                         this.args.size());
288                         for (int i = 0; i < this.args.size(); i++)
289                                 Msg.info("[" + this.msgName() + "/" + this.getHost().getName() +
290                                                 "] args[" + i + "]=" + (String) (this.args.get(i)));
291                 } catch(MsgException e) {
292                         Msg.info("Damn JNI stuff");
293                         e.printStackTrace();
294                         System.exit(1);
295                 }
296         }
297         /**
298          * This method runs the process. Il calls the method function that you must overwrite.
299          */
300         public void run() {
301
302                 String[]args = null;      /* do not fill it before the signal or this.args will be empty */
303
304                 //waitSignal(); /* wait for other people to fill the process in */
305
306
307                 try {
308                         schedBegin.acquire();
309                 } catch(InterruptedException e) {
310                 }
311
312                 try {
313                         args = new String[this.args.size()];
314                         if (this.args.size() > 0) {
315                                 this.args.toArray(args);
316                         }
317
318                         this.main(args);
319                         MsgNative.processExit(this);
320                         schedEnd.release();
321                 } catch(MsgException e) {
322                         e.printStackTrace();
323                         Msg.info("Unexpected behavior. Stopping now");
324                         System.exit(1);
325                 }
326         }
327
328         /**
329          * The main function of the process (to implement).
330          */
331         public abstract void main(String[]args) throws MsgException;
332
333
334         public void unschedule() {
335                 try {
336                         schedEnd.release();
337                         schedBegin.acquire();
338                 } catch(InterruptedException e) {
339                 }
340         }
341
342         public void schedule() {
343                 try {
344                         schedBegin.release();
345                         schedEnd.acquire();
346                 } catch(InterruptedException e) {
347                 }
348         }
349
350         /** Send the given task in the mailbox associated with the specified alias  (waiting at most given time) 
351          * @throws TimeoutException 
352          * @throws HostFailureException 
353          * @throws TransferFailureException */
354         public void taskSend(String mailbox, Task task, double timeout) throws TransferFailureException, HostFailureException, TimeoutException {
355                 MsgNative.taskSend(mailbox, task, timeout);
356         }
357
358         /** Send the given task in the mailbox associated with the specified alias
359          * @throws TimeoutException 
360          * @throws HostFailureException 
361          * @throws TransferFailureException */
362         public void taskSend(String mailbox, Task task) throws  TransferFailureException, HostFailureException, TimeoutException {
363                 MsgNative.taskSend(mailbox, task, -1);
364         }
365
366         /** Receive a task on mailbox associated with the specified mailbox */
367         public Task taskReceive(String mailbox) throws TransferFailureException, HostFailureException, TimeoutException {
368                 return MsgNative.taskReceive(mailbox, -1.0, null);
369         }
370
371         /** Receive a task on mailbox associated with the specified alias (waiting at most given time) */
372         public Task taskReceive(String mailbox, double timeout) throws  TransferFailureException, HostFailureException, TimeoutException {
373                 return MsgNative.taskReceive(mailbox, timeout, null);
374         }
375
376         /** Receive a task on mailbox associated with the specified alias from given sender */
377         public Task taskReceive(String mailbox, double timeout, Host host) throws  TransferFailureException, HostFailureException, TimeoutException {
378                 return MsgNative.taskReceive(mailbox, timeout, host);
379         }
380
381         /** Receive a task on mailbox associated with the specified alias from given sender*/
382         public Task taskReceive(String mailbox, Host host) throws  TransferFailureException, HostFailureException, TimeoutException {
383                 return MsgNative.taskReceive(mailbox, -1.0, host);
384         }
385 }