src/bindings/java/org/simgrid/msg/VM.java

   1 /*
   2  * JNI interface to virtual machine in Simgrid
   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 package org.simgrid.msg;
  12
  13 import org.simgrid.msg.Host;
  14 import org.simgrid.msg.Process;
  15
  16 public class VM extends Host{
  17         // Please note that we are not declaring a new bind variable
  18         //(the bind variable has been inherited from the super class Host)
  19
  20         /* Static functions */
  21         // GetByName is inherited from the super class Host
  22
  23
  24          private static VM[] vms=null;
  25     private Host currentHost;
  26
  27         /* Constructors / destructors */
  28     /**
  29          * Create a `basic' VM (i.e. 1 core, 1GB of RAM, other values are not taken into account).
  30          */
  31         public VM(Host host, String name) {
  32                 this(host,name,1,1024, -1, null, -1,0 , 0);
  33         }
  34
  35         /**
  36          * Create a  VM
  37          * @param host, Host node
  38          * @param name, name of the machine
  39          * @param nCore, number of core
  40          * @param ramSize, size of the RAM that should be allocated (in MBytes)
  41          * @param netCap (not used for the moment)
  42          * @param diskPath (not used for the moment)
  43          * @param diskSize (not used for the moment)
  44          * @param dpRate (dirty page rate MB/flop, if you don't know put zero ;))
  45          * @param migNetSpeed (network bandwith allocated for migrations in MB/s, if you don't know put zero ;))
  46          */
  47
  48         public VM(Host host, String name, int nCore,  long ramSize,
  49                         long netCap, String diskPath, long diskSize, long  dpRate,long migNetSpeed){
  50                 super();
  51                 super.name = name;
  52                 this.currentHost = host;
  53                 create(host, name, nCore, ramSize, netCap, diskPath, diskSize, dpRate, migNetSpeed);
  54                 VM.addVM(this);
  55         }
  56
  57         private static void addVM(VM vm){
  58                 VM[] vmsN=null;
  59                 int i=0;
  60                 if(VM.vms == null)
  61                         vmsN = new VM[1];
  62                 else
  63                         vmsN = new VM[vms.length+1];
  64
  65                 for (i=0; i<vmsN.length-1 ; i ++){
  66                         vmsN[i]=vms[i];
  67                 }
  68                 vmsN[i]=vm;
  69                 vms=vmsN;
  70         }
  71    public static VM[] all(){
  72                 return vms;
  73         }
  74         public static VM getVMByName(String name){
  75                 for (int i=0 ; i < vms.length ; i++){
  76                           if (vms[i].getName().equals(name))
  77                                         return vms[i];
  78                 }
  79                 return null;
  80         }
  81         protected void finalize() {
  82                 destroy();
  83         }
  84
  85
  86         /* JNI / Native code */
  87         /* get/set property methods are inherited from the Host class. */
  88
  89         /** Returns whether the given VM is currently suspended
  90          */
  91         public native int isCreated();
  92
  93         /** Returns whether the given VM is currently running
  94          */
  95         public native int isRunning();
  96
  97         /** Returns whether the given VM is currently running
  98          */
  99         public native int isMigrating();
 100
 101         /** Returns whether the given VM is currently suspended
 102          */
 103         public native int isSuspended();
 104
 105         /** Returns whether the given VM is currently saving
 106          */
 107         public native int isSaving();
 108
 109         /** Returns whether the given VM is currently saved
 110          */
 111         public native int isSaved();
 112
 113         /** Returns whether the given VM is currently restoring its state
 114          */
 115         public native boolean isRestoring();
 116
 117         /**
 118          * Natively implemented method create the VM.
 119          * @param nCore, number of core
 120          * @param ramSize, size of the RAM that should be allocated (in MB)
 121          * @param netCap (not used for the moment)
 122          * @param diskPath (not used for the moment)
 123          * @param diskSize (not used for the moment)
 124          * @param dpRate (dirty page rate in MB/flop, if you don't know put zero ;))
 125          * @param migNetSpeed (network bandwith allocated for migrations in MB/s, if you don't know put zero ;))
 126          */
 127         private native void create(Host host, String name, int nCore, long ramSize,
 128                          long netCap, String diskPath, long diskSize, long dpRate, long migNetSpeed);
 129
 130         /**
 131          * start the VM
 132          */
 133         public native void start();
 134
 135
 136         /**
 137          * Immediately kills all processes within the given VM. Any memory that they allocated will be leaked.
 138          * No extra delay occurs. If you want to simulate this too, you want to use a MSG_process_sleep() or something
 139          */
 140         public native void shutdown();
 141
 142         /**
 143          * Invoke native migration routine
 144         */
 145         public native void internalmig(Host destination);
 146
 147
 148         /** Change the host on which all processes are running
 149          * (pre-copy is implemented)
 150          */
 151         public void migrate(Host destination){
 152 //              String[] argsRx = new String[5];
 153 //              argsRx[1] = this.getName();
 154 //              argsRx[2] = this.currentHost.getName();
 155 //              argsRx[3] = destination.getName();
 156 //              argsRx[0] =  "__pr_mig_rx:"+argsRx[1]+"("+argsRx[2]+"-"+argsRx[3]+")";
 157 //              argsRx[4] = null; // TODO: Why ?
 158 //
 159 //              //Process rx = new Process(destination, argsRx[0], argsRx );
 160 //
 161 //              String[] argsTx = new String[5];
 162 //              argsTx[1] = this.getName();
 163 //              argsTx[2] = this.currentHost.getName();
 164 //              argsTx[3] = destination.getName();
 165 //              argsTx[0] =  "__pr_mig_tx:"+argsTx[1]+"("+argsTx[2]+"-"+argsTx[3]+")";
 166 //              argsTx[4] = null; // TODO: Why ?
 167 //
 168 //              //Process tx = new Process(this.currentHost, argsTx[0], argsRx );
 169 //
 170                 this.internalmig(destination);
 171         }
 172
 173         /** Immediately suspend the execution of all processes within the given VM
 174          *
 175          * No suspension cost occurs. If you want to simulate this too, you want to
 176          * use a \ref File.write() before or after, depending on the exact semantic
 177          * of VM suspend to you.
 178          */
 179         public native void suspend();
 180
 181         /** Immediately resumes the execution of all processes within the given VM
 182          *
 183          * No resume cost occurs. If you want to simulate this too, you want to
 184          * use a \ref File.read() before or after, depending on the exact semantic
 185          * of VM resume to you.
 186          */
 187         public native void resume();
 188
 189         /** Immediately suspend the execution of all processes within the given VM
 190          *  and save its state on the persistent HDD
 191          *  Not yet implemented (for the moment it behaves like suspend)
 192          *  No suspension cost occurs. If you want to simulate this too, you want to
 193          *  use a \ref File.write() before or after, depending on the exact semantic
 194          *  of VM suspend to you.
 195          */
 196         public native void save();
 197
 198         /** Immediately resumes the execution of all processes previously saved
 199          * within the given VM
 200          *  Not yet implemented (for the moment it behaves like resume)
 201          *
 202          * No resume cost occurs. If you want to simulate this too, you want to
 203          * use a \ref File.read() before or after, depending on the exact semantic
 204          * of VM resume to you.
 205          */
 206         public native void restore();
 207
 208
 209         /**
 210          * Destroy the VM
 211          */
 212         public native void destroy();
 213
 214
 215
 216         /**
 217          * Class initializer, to initialize various JNI stuff
 218          */
 219         public static native void nativeInit();
 220         static {
 221                 nativeInit();
 222         }
 223 }