Logo AND Algorithmique Numérique Distribuée

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