src/and/Mapping/Cluster.java

   1 package and.Mapping ;
   2
   3
   4 import java.io.Serializable;
   5 import java.util.ArrayList;
   6
   7
   8 /**
   9  * Class representing a computing nodes cluster
  10  * @author S&eacute;bastien Miqu&eacute;e
  11  *
  12  */
  13 public class Cluster implements Serializable
  14 {
  15         private static final long serialVersionUID = 1L;
  16
  17         private String name ;
  18         private ArrayList<GNode> nodes ;
  19         private ArrayList<GNode> freenodes ;
  20         private String site ;
  21         private int moreNode ;
  22
  23
  24         /**
  25          * Default constructor.
  26          */
  27         public Cluster()
  28         {
  29                 name = "" ;
  30                 nodes = new ArrayList<GNode>() ;
  31                 freenodes = new ArrayList<GNode>() ;
  32                 site = "" ;
  33                 moreNode = 0 ;
  34         }
  35
  36
  37         /**
  38          * Set the name of the cluster.
  39          * @param _name Cluster's name
  40          */
  41         public void setName( String _name )
  42         {
  43                 name = _name ;
  44         }
  45
  46
  47         /**
  48          * Adding a computing node to the cluster.
  49          * @param _n Node to be add
  50          */
  51         public void addGNode( GNode _n )
  52         {
  53                 if( _n != null )
  54                 {
  55                         _n.setInCluster( true ) ;
  56                         nodes.add( _n ) ;
  57
  58                         if( ! _n.getMapped() )
  59                         {
  60                                 freenodes.add( _n ) ;
  61                         }
  62                 }
  63         }
  64
  65
  66         /**
  67          * Return the list of computing nodes which are in the cluster.
  68          * @return The list of nodes
  69          */
  70         public ArrayList<GNode> getGNodes()
  71         {
  72                 return nodes ;
  73         }
  74
  75
  76         /**
  77          * Return cluster's name.
  78          * @return Cluster's name
  79          */
  80         public String getName()
  81         {
  82                 return name ;
  83         }
  84
  85
  86         /**
  87          * Return the amount of computing nodes in the cluster.
  88          * @return The amount of nodes
  89          */
  90         public int getNbGNode()
  91         {
  92                 return nodes.size() ;
  93         }
  94
  95
  96         /**
  97          * Set the site in which the cluster is.
  98          * @param _site Site's name
  99          */
 100         public void setSite( String _site )
 101         {
 102                 site = _site ;
 103         }
 104
 105
 106         /**
 107          * Return the site's name in which the cluster is.
 108          * @return The site's name
 109          */
 110         public String getSite()
 111         {
 112                 return site ;
 113         }
 114
 115
 116         /**
 117          * Test if a computing node is in the cluster.
 118          * @param _g The node to be tested
 119          * @return The position of the node
 120          */
 121         public int isIn( GNode _g )
 122         {
 123                 int pos = -1 ;
 124
 125                 if( _g != null )
 126                 {
 127                         for( int i = 0 ; i < nodes.size() ; i ++ )
 128                         {
 129                                 if( nodes.get( i ).getId() == _g.getId() )
 130                                 {
 131                                         pos = i ;
 132                                         break ;
 133                                 }
 134
 135                         }
 136                 }
 137
 138                 return pos ;
 139         }
 140
 141         /**
 142          * Return the next available computing node in the cluster.
 143          * @return The next node in the cluster
 144          */
 145         public GNode nextGNode()
 146         {
 147                 GNode ret = null ;
 148
 149                 if( freenodes.size() > 0 )
 150                 {
 151                         ret = freenodes.get( 0 ) ;
 152                 }
 153
 154                 return ret ;
 155         }
 156
 157
 158         /**
 159          * Return the next available computing node in the cluster,
 160          * according to the moreNode iterator.
 161          * @return The next node in the cluster
 162          */
 163         public GNode moreGNode()
 164         {
 165                 GNode ret = null ;
 166
 167                 if( freenodes.size() > 0 )
 168                 {
 169                         if( moreNode >= freenodes.size() )
 170                         {
 171                                 System.err.println( "No more free node available" );
 172                         } else {
 173                                 ret = freenodes.get( moreNode ) ;
 174                                 moreNode++ ;
 175                         }
 176                 }
 177
 178                 return ret ;
 179         }
 180
 181
 182         /**
 183          * (Re-)Initialize the moreNode counter.
 184          */
 185         public void initMoreGNode()
 186         {
 187                 moreNode = 0 ;
 188         }
 189
 190
 191         /**
 192          * Remove a failed node from the cluster.
 193          * @param _dead The failed node
 194          */
 195         public void removeGNode( GNode _dead )
 196         {
 197                 if( _dead != null )
 198                 {
 199                         if( _dead.getCluster().equals( name ) && _dead.getSite().equals( site )  )
 200                         {
 201                                 int i = 0 ;
 202                                 for( i = 0 ; i < nodes.size() ; i++ )
 203                                 {
 204                                         if( _dead.getId() == nodes.get( i ).getId() )
 205                                         {
 206                                                 nodes.remove( i ) ;
 207
 208                                                 int j = 0 ;
 209                                                 for( j = 0 ; j < freenodes.size() ; j++ )
 210                                                 {
 211                                                         if( freenodes.get(j).getId() == _dead.getId() )
 212                                                         {
 213                                                                 freenodes.remove( j ) ;
 214                                                                 break ;
 215                                                         }
 216                                                 }
 217
 218                                                 break ;
 219                                         }
 220                                 }
 221
 222                                 if( i > nodes.size() )
 223                                 {
 224                                         System.err.println( "(Cluster) The GNode was not found in the list!" );
 225                                 }
 226                         } else {
 227                                 System.err.println( "(Cluster) The GNode to be deleted is not mine!" ) ;
 228                         }
 229                 } else {
 230                         System.err.println( "(Cluster) The GNode to be deleted is null!" ) ;
 231                 }
 232         }
 233
 234
 235         /**
 236          * Set the mapped status of a node of the cluster.
 237          * @param _g The mapped node
 238          * @param _status The status of the node
 239          */
 240         public void setGNodeStatus( GNode _g, boolean _status )
 241         {
 242                 if( _g != null )
 243                 {
 244                         for( int i = 0 ; i < nodes.size() ; i++ )
 245                         {
 246                                 if( nodes.get( i ).getId() == _g.getId() )
 247                                 {
 248                                         nodes.get( i ).setMapped( _status ) ;
 249
 250                                         if( _status )
 251                                         {
 252                                                 for( int j = 0 ; j < freenodes.size() ; j++ )
 253                                                 {
 254                                                         if( freenodes.get(j).getId() == nodes.get(i).getId() )
 255                                                         {
 256                                                                 freenodes.remove( j ) ;
 257                                                                 break ;
 258                                                         }
 259                                                 }
 260
 261                                         } else {
 262                                                 if( ! freenodes.contains( nodes.get( i ) ) )
 263                                                         freenodes.add( nodes.get( i ) ) ;
 264                                         }
 265                                 }
 266                         }
 267                 }
 268         }
 269
 270
 271         /**
 272          * Return the amount of available free nodes in the cluster.
 273          * @return The amount of free nodes
 274          */
 275         public int getNbFreeNodes()
 276         {
 277                 return freenodes.size() ;
 278         }
 279
 280
 281         /**
 282          * Compute and return the available computing power of the cluster.
 283          * @return The available computing power
 284          */
 285         public double getAvailablePower()
 286         {
 287                 double ret = 0 ;
 288
 289                 /** If there is some available nodes **/
 290                 if( freenodes.size() > 0 )
 291                 {
 292                         for( int i = 0 ; i < freenodes.size() ; i++ )
 293                         {
 294                                 ret += freenodes.get( i ).getPower() ;
 295                         }
 296                 }
 297
 298                 return ret ;
 299         }
 300
 301
 302         /**
 303          * Compute and return the average available computing power of the cluster.
 304          * @return The available available computing power
 305          */
 306         public double getAvgAvailablePower()
 307         {
 308                 double ret = 0 ;
 309
 310                 /** If there is some available nodes **/
 311                 if( freenodes.size() > 0 )
 312                 {
 313                         for( int i = 0 ; i < freenodes.size() ; i++ )
 314                         {
 315                                 ret += freenodes.get( i ).getPower() ;
 316                         }
 317
 318                         ret = ret / freenodes.size() ;
 319                 }
 320
 321                 return ret ;
 322         }
 323
 324
 325         public double getAvgPower()
 326         {
 327                 double ret = 0 ;
 328
 329                 /** If there is some available nodes **/
 330                 if( nodes.size() > 0 )
 331                 {
 332                         for( int i = 0 ; i < nodes.size() ; i++ )
 333                         {
 334                                 ret += nodes.get( i ).getPower() ;
 335                         }
 336
 337                         ret = ret / nodes.size() ;
 338                 }
 339
 340                 return ret ;
 341         }
 342
 343
 344         public double getPower()
 345         {
 346                 double ret = 0 ;
 347
 348                 /** If there is some available nodes **/
 349                 if( nodes.size() > 0 )
 350                 {
 351                         for( int i = 0 ; i < nodes.size() ; i++ )
 352                         {
 353                                 ret += nodes.get( i ).getPower() ;
 354                         }
 355                 }
 356
 357                 return ret ;
 358         }
 359
 360         /**
 361          * Initialization of computing nodes in this cluster. Set all
 362          * of these nodes to be not mapped on.
 363          */
 364         public void initGNodes()
 365         {
 366                 /** Initialization of local nodes            **/
 367                 /** and reconstruction of the freenodes list **/
 368                 freenodes = null ;
 369                 freenodes = new ArrayList<GNode>() ;
 370
 371                 for( int i = 0 ; i < nodes.size() ; i++ )
 372                 {
 373                         nodes.get( i ).setMapped( false ) ;
 374
 375                         freenodes.add( nodes.get( i ) ) ;
 376                 }
 377         }
 378
 379 }
 380
 381 /** La programmation est un art, respectons ceux qui la pratiquent !! **/