src/and/Mapping/Utils.java

   1 package and.Mapping ;
   2
   3 import java.io.FileInputStream;
   4 import java.io.FileNotFoundException;
   5 import java.io.FileOutputStream;
   6 import java.io.OutputStreamWriter;
   7 import java.io.PrintWriter;
   8 import java.net.InetAddress;
   9 import java.util.ArrayList;
  10
  11 import com.thoughtworks.xstream.XStream;
  12 import com.thoughtworks.xstream.io.xml.DomDriver;
  13
  14
  15
  16 /**
  17  * Class providing some tools to the library
  18  * @author S&eacute;astien Miqu&eacute;e
  19  */
  20 public class Utils
  21 {
  22         /**
  23          * Creation of the representation of the node in the Mapping point of view. It needs
  24          * some information about the computing node, which will be exploited by mapping
  25          * algorithms.
  26          * @return A node from the Mapping library
  27          */
  28         public static GNode createGNode()
  29         {
  30                 /** Using the Linpack class **/
  31                 Linpack linpack = new Linpack() ;
  32
  33                 /**  **/
  34                 GNode n = new GNode() ;
  35                 int nbCore = 0 ;
  36                 int frequency = 0 ;
  37                 int mflops = 0 ;
  38                 int memory = 0 ;
  39                 String name = "" ;
  40
  41
  42                 /** CPU information **/
  43
  44                 /* Amount of available computing cores */
  45                 nbCore = Runtime.getRuntime().availableProcessors() ;
  46
  47                 /* Average MegaFlops of each core */
  48                 double tmp_mflops = 0 ;
  49                 int loop = 10 ;
  50
  51                 for( int i = 0 ; i < loop ; i++ )
  52                 {
  53                         tmp_mflops += linpack.getMFlops() ;
  54                         System.gc() ;
  55                 }
  56                 mflops = (int) tmp_mflops / loop ;
  57
  58
  59                 /** Memory information **/
  60                 memory = (int) Runtime.getRuntime().maxMemory() / 1024 / 1024 ;
  61
  62
  63                 /* Host name */
  64                 try {
  65                         InetAddress addr = InetAddress.getLocalHost() ;
  66                         name = new String( addr.getCanonicalHostName() ) ;
  67                 } catch( final Exception e ) {
  68                         System.err.println( "Unalbe to retrieve host name !" ) ;
  69                         e.printStackTrace();
  70                         System.exit( 1 ) ;
  71                 }
  72
  73
  74                 /* Updating node information */
  75                 n.setFrequency( frequency ) ;
  76                 n.setMFlops( mflops ) ;
  77                 n.setMemory( memory ) ;
  78                 n.setNb_cores( nbCore ) ;
  79                 n.setName( name ) ;
  80
  81                 return n ;
  82         }
  83
  84         /**
  85          * Creation of the representation of the grid, according to clusters into sites.
  86          * This representation may only fit on Grid'5000 like architectures (with computing
  87          * nodes name based on the following pattern |cluster_name|id_of_node_into_cluster|.|site_of_cluster|.|organisation|.*|).
  88          * @param _an the list of computing nodes connected
  89          * @return the grid's architecture
  90          */
  91         public static Grid createGridG5k( ArrayList<GNode> _an )
  92         {
  93                 Grid gr = new Grid() ;
  94
  95                 if( _an != null )
  96                 {
  97                         String temp ;
  98                         String nom, cluster, site ;
  99
 100
 101                         ArrayList<Cluster> clusters = new ArrayList<Cluster>() ;
 102
 103                         for( int i = 0 ; i < _an.size() ; i++ )
 104                         {
 105                                 /* Variables edition */
 106                                 String tab[] = new String[ 5 ] ;
 107
 108                                 temp = _an.get( i ).getName().trim().replace('.', '!' ) ;
 109
 110                                 tab = temp.split( "!" ) ;
 111
 112                                 nom = tab[ 0 ] ;
 113                                 site = tab[ 1 ] ;
 114
 115                                 tab = nom.split( "-" ) ;
 116
 117                                 // IUT
 118                                 //cluster = "iut" ;
 119
 120                                 // G5K
 121                                 cluster = tab[ 0 ] ;
 122
 123                                 //System.out.println( nom + " dans " + cluster + " du site " + site ) ;
 124
 125
 126                                 /* Insertion du noeud dans son cluster */
 127                                 boolean trouve = false ;
 128
 129                                 for( int j = 0 ; j < clusters.size() ; j++ )
 130                                 {
 131                                         if( clusters.get( j ).getName().equals( cluster ) && clusters.get( j ).getSite().equals( site ))
 132                                         {
 133                                                 _an.get( i ).setInCluster( true ) ;
 134                                                 _an.get( i ).setSite( clusters.get( j ).getSite() ) ;
 135                                                 _an.get( i ).setCluster( clusters.get( j ).getName() ) ;
 136                                                 clusters.get( j ).addGNode( _an.get( i ) ) ;
 137                                                 trouve  = true ;
 138
 139                                                 break ;
 140                                         }
 141                                 }
 142
 143                                 if( ! trouve )
 144                                 {
 145                                         Cluster cl = new Cluster() ;
 146
 147                                         cl.setName( cluster ) ;
 148                                         cl.setSite( site ) ;
 149
 150                                         _an.get( i ).setInCluster( true ) ;
 151                                         _an.get( i ).setSite( site ) ;
 152                                         _an.get( i ).setCluster( cluster ) ;
 153
 154                                         cl.addGNode( _an.get( i ) ) ;
 155
 156                                         clusters.add( cl ) ;
 157                                 }
 158                         }
 159
 160                         gr.addClusters( clusters ) ;
 161
 162                 }
 163
 164                 return gr ;
 165         }
 166
 167
 168         /**
 169          * Write the Grid object in an XML file.
 170          * @param _gl Grid graph to be write
 171          * @param _file File's name
 172          * @param _path File's path
 173          */
 174         public static void writeGrid( Grid _gl, String _file, String _path )
 175         {
 176                 if ( ! _file.equals( "" ) && ! _file.endsWith( ".xml" ) )
 177                 {
 178                         _file = _file + ".xml"; // On ajoute l'extension xml au nom du fichier
 179                 }
 180
 181                 if( ! _file.equals( "" ) )
 182                 {
 183                         String path = "" ;
 184
 185                         if( _path.length() != 0 )
 186                         {
 187                                 path = _path+"/"+_file ;
 188                         } else {
 189                                 path = new String( "./" + _file ) ;
 190                         }
 191
 192                         XStream xstream = new XStream( new DomDriver() ) ;
 193
 194                         String xml = xstream.toXML( _gl ) ;
 195
 196                         PrintWriter ecrivain = null ;
 197
 198                         try {
 199                                 ecrivain = new PrintWriter( new OutputStreamWriter( new FileOutputStream( path ), "UTF8" ) ) ;
 200
 201                                 ecrivain.println( "<?xml version=\"1.0\" encoding=\"UTF8\"?>" ) ;
 202                                 ecrivain.println( xml ) ;
 203
 204                                 ecrivain.close() ;
 205                         } catch( Exception e ) {
 206                                 System.err.println( "\nError during the write opération !\n" ) ;
 207                                 e.printStackTrace() ;
 208                         }
 209                 }
 210         }
 211
 212         /**
 213          * Write an application Graph in a file.
 214          * @param _gr Application Graph to be write
 215          * @param _file File's name
 216          * @param _path File's path
 217          */
 218         public static void writeGraph( Graph _gr, String _file, String _path )
 219         {
 220                 if ( ! _file.equals( "" ) && ! _file.endsWith( ".xml" ) )
 221                 {
 222                         _file = _file + ".xml"; // On ajoute l'extension xml au nom du fichier
 223                 }
 224
 225                 if( ! _file.equals( "" ) )
 226                 {
 227                         String path = "" ;
 228
 229                         if( _path.length() != 0 )
 230                         {
 231                                 path = _path+"/"+_file ;
 232                         } else {
 233                                 path = new String( "./" + _file ) ;
 234                         }
 235
 236                         XStream xstream = new XStream( new DomDriver() ) ;
 237
 238                         String xml = xstream.toXML( _gr ) ;
 239
 240                         PrintWriter ecrivain = null ;
 241
 242                         try {
 243                                 ecrivain = new PrintWriter( new OutputStreamWriter( new FileOutputStream( path ), "UTF8" ) ) ;
 244
 245                                 ecrivain.println( "<?xml version=\"1.0\" encoding=\"UTF8\"?>" ) ;
 246                                 ecrivain.println( xml ) ;
 247
 248                                 ecrivain.close() ;
 249                         } catch( Exception e ) {
 250                                 System.err.println( "\nError during the write opération !\n" ) ;
 251                                 e.printStackTrace() ;
 252                         }
 253                 }
 254         }
 255
 256
 257         /**
 258          * Read an application Graph from a file.
 259          * @param _file File's name
 260          * @return The application Graph read
 261          */
 262         public static Graph readGraph( String _file )
 263         {
 264                 if ( _file.equals( "" ) || ! _file.endsWith( ".xml" ) )
 265                 {
 266                         System.err.println( "Bad file !\n" ) ;
 267                         return null ;
 268                 }
 269
 270                 Graph gr = null ;
 271
 272                 XStream xstream = new XStream( new DomDriver() ) ;
 273
 274                 try {
 275                         gr = (Graph) xstream.fromXML( new FileInputStream( _file ) ) ;
 276                 } catch( FileNotFoundException e ) {
 277                         System.err.println( "File not found !\n" ) ;
 278                         e.printStackTrace();
 279                         return null ;
 280                 } catch( ClassCastException e ) {
 281                         System.err.println( "The file does not contain a Graph" ) ;
 282                         e.printStackTrace() ;
 283                         return null ;
 284                 }
 285
 286                 return gr ;
 287         }
 288
 289
 290         /**
 291          * Read a Grid graph from a file.
 292          * @param _file File's name
 293          * @return The Grid graph read
 294          */
 295         public static Grid readGrid( String _file )
 296         {
 297                 if ( _file.equals( "" ) || ! _file.endsWith( ".xml" ) )
 298                 {
 299                         System.err.println( "Bad file !\n" ) ;
 300                         return null ;
 301                 }
 302
 303                 Grid gr = null ;
 304
 305                 XStream xstream = new XStream( new DomDriver() ) ;
 306
 307                 try {
 308                         gr = (Grid) xstream.fromXML( new FileInputStream( _file ) ) ;
 309                 } catch( FileNotFoundException e ) {
 310                         System.err.println( "File not found !\n" ) ;
 311                         e.printStackTrace();
 312                         return null ;
 313                 } catch( ClassCastException e ) {
 314                         System.err.println( "The file does not contain a Grid" ) ;
 315                         e.printStackTrace() ;
 316                         return null ;
 317                 }
 318
 319                 return gr ;
 320         }
 321
 322 }
 323
 324
 325 /** La programmation est un art, respectons ceux qui la pratiquent !! **/