Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
ba290f864a18702507142643564d0f941dc5cfa7
[simgrid.git] / org / simgrid / msg / Msg.java
1 /*
2  * JNI interface to C code for MSG.
3  * 
4  * Copyright 2006-2012 The SimGrid Team.           
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 org.simgrid.msg;
13
14 import java.io.FileOutputStream;
15 import java.io.InputStream;
16 import java.io.OutputStream;
17 import java.io.File;
18
19
20 public final class Msg {
21         /* Statically load the library which contains all native functions used in here */
22         static {
23                 try {
24                         /* prefer the version on disk, if existing */
25                         System.loadLibrary("SG_java");
26                 } catch (UnsatisfiedLinkError e) {
27                         /* If not found, unpack the one bundled into the jar file and use it */
28                         loadLib("simgrid");
29                         loadLib("SG_java");
30                 }
31         }
32         private static void loadLib (String name) {
33                 String Path = "NATIVE/"+System.getProperty("os.name")+"/"+System.getProperty("os.arch")+"/";
34                 String filename=name;
35                 InputStream in = Msg.class.getClassLoader().getResourceAsStream(Path+filename);
36                 
37                 if (in == null) {
38                         filename = "lib"+name+".so";
39                         in = Msg.class.getClassLoader().getResourceAsStream(Path+filename);
40                 } 
41                 if (in == null) {
42                         filename = name+".dll";
43                         in = Msg.class.getClassLoader().getResourceAsStream(Path+filename);
44                 }  
45                 if (in == null) {
46                         filename = "lib"+name+".dylib";
47                         in = Msg.class.getClassLoader().getResourceAsStream(Path+filename);
48                 }  
49                 if (in == null) {
50                         throw new RuntimeException("Cannot find library "+name+" in path "+Path+". Sorry, but this jar does not seem to be usable on your machine.");
51                 }
52 // Caching the file on disk: desactivated because it could fool the users               
53 //              if (new File(filename).isFile()) {
54 //                      // file was already unpacked -- use it directly
55 //                      System.load(new File(".").getAbsolutePath()+File.separator+filename);
56 //                      return;
57 //              }
58                 try {
59                         // We must write the lib onto the disk before loading it -- stupid operating systems
60                         File fileOut = new File(filename);
61 //                      if (!new File(".").canWrite()) {
62 //                              System.out.println("Cannot write in ."+File.separator+filename+"; unpacking the library into a temporary file instead");
63                                 fileOut = File.createTempFile("simgrid-", ".tmp");
64                                 // don't leak the file on disk, but remove it on JVM shutdown
65                                 Runtime.getRuntime().addShutdownHook(new Thread(new FileCleaner(fileOut.getAbsolutePath())));
66 //                      }
67 //                      System.out.println("Unpacking SimGrid native library to " + fileOut.getAbsolutePath());
68                         OutputStream out = new FileOutputStream(fileOut);
69                         
70                         /* copy the library in position */  
71                         byte[] buffer = new byte[4096]; 
72                         int bytes_read; 
73                         while ((bytes_read = in.read(buffer)) != -1)     // Read until EOF
74                                 out.write(buffer, 0, bytes_read); 
75                       
76                         /* close all file descriptors, and load that shit */
77                         in.close();
78                         out.close();
79                         System.load(fileOut.getAbsolutePath());
80                 } catch (Exception e) {
81                         System.err.println("Cannot load the bindings to the simgrid library: ");
82                         e.printStackTrace();
83                         System.err.println("This jar file does not seem to fit your system, sorry");
84                         System.exit(1);
85                 }
86         }               
87         /* A hackish mechanism used to remove the file containing our library when the JVM shuts down */
88         private static class FileCleaner implements Runnable {
89                 private String target;
90                 public FileCleaner(String name) {
91                         target = name;
92                 }
93         public void run() {
94             try {
95                 new File(target).delete();
96             } catch(Exception e) {
97                 System.out.println("Unable to clean temporary file "+target+" during shutdown.");
98                 e.printStackTrace();
99             }
100         }    
101         }
102
103     /** Retrieve the simulation time
104      * @return
105      */
106         public final static native double getClock();
107         /**
108          * Issue a debug logging message.
109          * @param s message to log.
110          */
111         public final static native void debug(String s);
112         /**
113          * Issue an verbose logging message.
114          * @param s message to log.
115          */
116         public final static native void verb(String s);
117
118         /** Issue an information logging message
119      * @param s
120      */
121         public final static native void info(String s);
122         /**
123          * Issue an warning logging message.
124          * @param s message to log.
125          */
126         public final static native void warn(String s);
127         /**
128          * Issue an error logging message.
129          * @param s message to log.
130          */
131         public final static native void error(String s);
132         /**
133          * Issue an critical logging message.
134          * @param s message to log.
135          */
136         public final static native void critical(String s);
137
138         /*********************************************************************************
139          * Deployment and initialization related functions                               *
140          *********************************************************************************/
141
142         /**
143          * The natively implemented method to initialize a MSG simulation.
144          *
145          * @param args            The arguments of the command line of the simulation.
146          *
147          * @see                    Msg.init()
148          */
149         public final static native void init(String[]args);
150
151         /**
152          * Run the MSG simulation.
153          *
154          * The simulation is not cleaned afterward (see  
155          * {@link #clean()} if you really insist on cleaning the C side), so you can freely 
156          * retrieve the informations that you want from the simulation. In particular, retrieving the status 
157          * of a process or the current date is perfectly ok. 
158          *
159          * @see                    MSG_run
160          */
161         public final static native void run() ;
162         
163         /** This function is useless nowadays, just stop calling it. */
164         @Deprecated
165         public final static void clean(){}
166
167         /**
168          * The native implemented method to create the environment of the simulation.
169          *
170          * @param platformFile    The XML file which contains the description of the environment of the simulation
171          *
172          */
173         public final static native void createEnvironment(String platformFile);
174
175         /**
176          * The method to deploy the simulation.
177          *
178      *
179      * @param deploymentFile
180      */
181         public final static native void deployApplication(String deploymentFile);
182
183     /** Example launcher. You can use it or provide your own launcher, as you wish
184      * @param args
185      * @throws MsgException
186      */
187         static public void main(String[]args) throws MsgException {
188                 /* initialize the MSG simulation. Must be done before anything else (even logging). */
189                 Msg.init(args);
190
191                 if (args.length < 2) {
192                         Msg.info("Usage: Msg platform_file deployment_file");
193                         System.exit(1);
194                 }
195
196                 /* Load the platform and deploy the application */
197                 Msg.createEnvironment(args[0]);
198                 Msg.deployApplication(args[1]);
199                 /* Execute the simulation */
200                 Msg.run();
201         }
202 }