Lab Manual

Cloud Computing Lab (MCO 017A)

M.Tech.2nd Year(II Sem)

CSE
Academic Session(2015-2016)

Submitted By:

Ajay Kumar
Assistant Professor-I
Department of Computer Science and Engineering
M.Tech. in Computer Science & Engineering (Information Security) Semester II

MCO 017A Cloud Computing lab 0-0-2

Basic Exercises

1. Create a simulation showing how to create a datacenter with one host and run one
cloudlet on it.
2. Create a simulation showing how to create two datacenters with one host and a network
topology each and run two cloudlets on them.
3. Create a simulation showing how to create two datacenters with one host each and run
cloudlets of two users with network topology on them.
4. Create a simulation showing how to create two datacenters with one host each and run
two cloudlets on them.
5. Create a simulation showing how to create two datacenters with one host each and run
cloudlets of two users on them.
6. An example showing how to create scalable simulations.
7. An example showing how to pause and resume the simulation, and create simulation
entities (a Datacenter Broker in this example) dynamically.
8. An example showing how to create simulation entities (a DatacenterBroker in this
example) in run-time using a globar manager entity (GlobalBroker).

Network Exercises

1. Create a simulation showing how to create a datacenter with one host and a network
topology and and run one cloudlet on it.
2. Create a simulation showing how to create two datacenters with one host and a network
topology each and run two cloudlets on them.
3. Create a simulation showing how to create two datacenters with one host each and run
cloudlets of two users with network topology on them.
4. Create a simulation showing how to create a datacenter with one host and a network
topology and and run one cloudlet on it. Here, instead of using a BRIE file describing the
links, links are inserted in the code.

Power Exercises

1. A simulation of a heterogeneous non-power aware data center: all hosts consume

maximum power all the time.
2. A simulation of a heterogeneous power aware data center that only applied DVFS, but no
dynamic optimization of the VM allocation. The adjustment of the hosts' power
consumption according to their CPU utilization is happening in the PowerDatacenter
class.
3. A simulation of a heterogeneous power aware data center that applies the Static
Threshold (THR) VM allocation policy and Random Selection (RS) VM selection policy.
Basic Exercises

1. Create a simulation showing how to create a datacenter with one host and run one cloudlet
on it.

package org.cloudbus.cloudsim.examples;

/*
* Title: CloudSim Toolkit
* Description: CloudSim (Cloud Simulation) Toolkit for Modeling and
Simulation
* of Clouds
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
*
*
*/

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerTimeShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;

/**
* A simple example showing how to create a datacenter with one host
and run one
* cloudlet on it.
*/
public class CloudSimExample1 {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList;

/** The vmlist. */

private static List<Vm> vmlist;
 /**
* Creates main() to run this example.
*
* @param args the args
*/
public static void main(String[] args) {

Log.printLine("Starting CloudSimExample1...");

try {
// First step: Initialize the CloudSim package. It
should be called
// before creating any entities.
int num_user = 1; // number of cloud users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events

// Initialize the CloudSim library

CloudSim.init(num_user, calendar, trace_flag);

// Second step: Create Datacenters

// Datacenters are the resource providers in
CloudSim. We need at
// list one of them to run a CloudSim simulation
Datacenter datacenter0 =
createDatacenter("Datacenter_0");

// Third step: Create Broker

DatacenterBroker broker = createBroker();
int brokerId = broker.getId();

// Fourth step: Create one virtual machine

vmlist = new ArrayList<Vm>();

// VM description
int vmid = 0;
int mips = 1000;
long size = 10000; // image size (MB)
int ram = 512; // vm memory (MB)
long bw = 1000;
int pesNumber = 1; // number of cpus
int priority = 1;
String vmm = "Xen"; // VMM name

// create VM
Vm vm = new Vm(vmid, brokerId, mips, pesNumber,
ram, bw, size, priority, vmm, new CloudletSchedulerTimeShared());

// add the VM to the vmList

vmlist.add(vm);

// submit vm list to the broker

broker.submitVmList(vmlist);
 // Fifth step: Create one Cloudlet
cloudletList = new ArrayList<Cloudlet>();

// Cloudlet properties
int id = 0;
long length = 400000;
long fileSize = 300;
long outputSize = 300;
UtilizationModel utilizationModel = new
UtilizationModelFull();

Cloudlet cloudlet = new Cloudlet(id, length,

pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet.setUserId(brokerId);
cloudlet.setVmId(vmid);

// add the cloudlet to the list

cloudletList.add(cloudlet);

// submit cloudlet list to the broker

broker.submitCloudletList(cloudletList);

// Sixth step: Starts the simulation

CloudSim.startSimulation();

CloudSim.stopSimulation();

//Final step: Print results when simulation is

over
List<Cloudlet> newList =
broker.getCloudletReceivedList();
printCloudletList(newList);

// Print the debt of each user to each datacenter

datacenter0.printDebts();

Log.printLine("CloudSimExample1 finished!");
} catch (Exception e) {
e.printStackTrace();
Log.printLine("Unwanted errors happen");
}
}

/**
* Creates the datacenter.
*
* @param name the name
*
* @return the datacenter
*/
private static Datacenter createDatacenter(String name) {

// Here are the steps needed to create a PowerDatacenter:

// 1. We need to create a list to store
 // our machine
List<Host> hostList = new ArrayList<Host>();

// 2. A Machine contains one or more PEs or CPUs/Cores.

// In this example, it will have only one core.
List<Pe> peList = new ArrayList<Pe>();

int mips = 1000;

// 3. Create PEs and add these into a list.

peList.add(new Pe(0, new PeProvisionerSimple(mips))); //
need to store Pe id and MIPS Rating

// 4. Create Host with its id and list of PEs and add

them to the list
// of machines
int hostId = 0;
int ram = 2048; // host memory (MB)
long storage = 1000000; // host storage
int bw = 10000;

hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList,
new VmSchedulerTimeShared(peList)
)
); // This is our machine

// 5. Create a DatacenterCharacteristics object that

stores the
// properties of a data center: architecture, OS, list of
// Machines, allocation policy: time- or space-shared,
time zone
// and its price (G$/Pe time unit).
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource
located
double cost = 3.0; // the cost of using processing in
this resource
double costPerMem = 0.05; // the cost of using memory in
this resource
double costPerStorage = 0.001; // the cost of using
storage in this
/
/ resource
double costPerBw = 0.0; // the cost of using bw in this
resource
LinkedList<Storage> storageList = new
LinkedList<Storage>(); // we are not adding SAN
 // devices by now

DatacenterCharacteristics characteristics = new

DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost,
costPerMem,
costPerStorage, costPerBw);

// 6. Finally, we need to create a PowerDatacenter

object.
Datacenter datacenter = null;
try {
datacenter = new Datacenter(name, characteristics,
new VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}

// We strongly encourage users to develop their own broker

policies, to
// submit vms and cloudlets according
// to the specific rules of the simulated scenario
/**
* Creates the broker.
*
* @return the datacenter broker
*/
private static DatacenterBroker createBroker() {
DatacenterBroker broker = null;
try {
broker = new DatacenterBroker("Broker");
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}

/**
* Prints the Cloudlet objects.
*
* @param list list of Cloudlets
*/
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent
 + "Data center ID" + indent + "VM ID" +
indent + "Time" + indent
+ "Start Time" + indent + "Finish Time");

DecimalFormat dft = new DecimalFormat("###.##");

for (int i = 0; i < size; i++) {
cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() +
indent + indent);

if (cloudlet.getCloudletStatus() ==
Cloudlet.SUCCESS) {
Log.print("SUCCESS");

Log.printLine(indent + indent +
cloudlet.getResourceId()
+ indent + indent + indent +
cloudlet.getVmId()
+ indent + indent
+
dft.format(cloudlet.getActualCPUTime()) + indent
+ indent +
dft.format(cloudlet.getExecStartTime())
+ indent + indent
+
dft.format(cloudlet.getFinishTime()));
}
}
}

}
2. Create a simulation showing how to create two datacenters with one host and a network topology
each and run two cloudlets on them.

*
 * Title:        CloudSim Toolkit
 * Description:  CloudSim (Cloud Simulation) Toolkit for Modeling and
Simulation
 *               of Clouds
 * Licence:      GPL - http://www.gnu.org/copyleft/gpl.html
 *
 *
 */
package org.cloudbus.cloudsim.examples.network;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;
import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.NetworkTopology;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerTimeShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;
/**
 * A simple example showing how to create
 * two datacenters with one host and a
 * network topology each and run two cloudlets
 * on them.
 */
public class NetworkExample2 {
        /** The cloudlet list. */
        private static List<Cloudlet> cloudletList;
        /** The vmlist. */
        private static List<Vm> vmlist;
        /**
         * Creates main() to run this example
         */
        public static void main(String[] args) {
                Log.printLine("Starting NetworkExample2...");
                try {
                        // First step: Initialize the CloudSim
package. It should be called
                        // before creating any entities.
                        int num_user = 1;   // number of cloud users
                        Calendar calendar = Calendar.getInstance();
                        boolean trace_flag = false;  // mean trace
events
                        // Initialize the CloudSim library
                        CloudSim.init(num_user, calendar, trace_flag);
                        // Second step: Create Datacenters
                        //Datacenters are the resource providers in
CloudSim. We need at list one of them to run a CloudSim simulation
                        Datacenter datacenter0 =
createDatacenter("Datacenter_0");
                        Datacenter datacenter1 =
createDatacenter("Datacenter_1");
                        //Third step: Create Broker
                        DatacenterBroker broker = createBroker();
                        int brokerId = broker.getId();
                        //Fourth step: Create one virtual machine
                        vmlist = new ArrayList<Vm>();
                        //VM description
                        int vmid = 0;
                        int mips = 250;
                        long size = 10000; //image size (MB)
                        int ram = 512; //vm memory (MB)
                        long bw = 1000;
                        int pesNumber = 1; //number of cpus
                        String vmm = "Xen"; //VMM name
                        //create two VMs
                        Vm vm1 = new Vm(vmid, brokerId, mips,
pesNumber, ram, bw, size, vmm, new CloudletSchedulerTimeShared());
                        //the second VM will have twice the priority
of VM1 and so will receive twice CPU time
                        vmid++;
                        Vm vm2 = new Vm(vmid, brokerId, mips,
pesNumber, ram, bw, size, vmm, new CloudletSchedulerTimeShared());
                        //add the VMs to the vmList
                        vmlist.add(vm1);
                        vmlist.add(vm2);
                        //submit vm list to the broker
                        broker.submitVmList(vmlist);
                        //Fifth step: Create two Cloudlets
                        cloudletList = new ArrayList<Cloudlet>();
                        //Cloudlet properties
                        int id = 0;
                        long length = 40000;
                        long fileSize = 300;
                        long outputSize = 300;
                        UtilizationModel utilizationModel = new
UtilizationModelFull();
                        Cloudlet cloudlet1 = new Cloudlet(id, length,
pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
                        cloudlet1.setUserId(brokerId);
                        id++;
                        Cloudlet cloudlet2 = new Cloudlet(id, length,
pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
                        cloudlet2.setUserId(brokerId);
                        //add the cloudlets to the list
                        cloudletList.add(cloudlet1);
                        cloudletList.add(cloudlet2);
                        //submit cloudlet list to the broker
                        broker.submitCloudletList(cloudletList);
                        //bind the cloudlets to the vms. This way, the
broker
                        // will submit the bound cloudlets only to the
specific VM
                       
broker.bindCloudletToVm(cloudlet1.getCloudletId(),vm1.getId());
                       
broker.bindCloudletToVm(cloudlet2.getCloudletId(),vm2.getId());
                        //Sixth step: configure network
                        //load the network topology file
                       
NetworkTopology.buildNetworkTopology("topology.brite");
                        //maps CloudSim entities to BRITE entities
                        //Datacenter0 will correspond to BRITE node 0
                        int briteNode=0;
                       
NetworkTopology.mapNode(datacenter0.getId(),briteNode);
                        //Datacenter1 will correspond to BRITE node 2
                        briteNode=2;
                       
NetworkTopology.mapNode(datacenter1.getId(),briteNode);
                        //Broker will correspond to BRITE node 3
                        briteNode=3;
                       
NetworkTopology.mapNode(broker.getId(),briteNode);
                        // Sixth step: Starts the simulation
                        CloudSim.startSimulation();
                        // Final step: Print results when simulation
is over
                        List<Cloudlet> newList =
broker.getCloudletReceivedList();
                        CloudSim.stopSimulation();
                        printCloudletList(newList);
                        Log.printLine("NetworkExample2 finished!");
                }
                catch (Exception e) {
                        e.printStackTrace();
                        Log.printLine("The simulation has been
terminated due to an unexpected error");
                }
        }
        private static Datacenter createDatacenter(String name){
                // Here are the steps needed to create a
PowerDatacenter:
                // 1. We need to create a list to store
                //    our machine
                List<Host> hostList = new ArrayList<Host>();
                // 2. A Machine contains one or more PEs or
CPUs/Cores.
                // In this example, it will have only one core.
                List<Pe> peList = new ArrayList<Pe>();
                int mips = 1000;
                // 3. Create PEs and add these into a list
                peList.add(new Pe(0, new PeProvisionerSimple(mips)));
// need to store Pe id and MIPS Rating
                //4. Create Host with its id and list of PEs and add
them to the list of machines
                int hostId=0;
                int ram = 2048; //host memory (MB)
                long storage = 1000000; //host storage
                int bw = 10000;
                //in this example, the VMAllocatonPolicy in use is
Time Shared with priorities. It means that VMs
                //receive time shares accroding to their priority.
                hostList.add(
                                new Host(
                                        hostId,
                                        new RamProvisionerSimple(ram),
                                        new BwProvisionerSimple(bw),
                                        storage,
                                        peList,
                                        new
VmSchedulerTimeShared(peList)
                                )
                        ); // This is our machine
                // 5. Create a DatacenterCharacteristics object that
stores the
                //    properties of a data center: architecture, OS,
list of
                //    Machines, allocation policy: time- or space-
shared, time zone
                //    and its price (G$/Pe time unit).
                String arch = "x86";      // system architecture
                String os = "Linux";          // operating system
                String vmm = "Xen";
                double time_zone = 10.0;         // time zone this
resource located
                double cost = 3.0;              // the cost of using
processing in this resource
                double costPerMem = 0.05;               // the cost of
using memory in this resource
                double costPerStorage = 0.001;  // the cost of using
storage in this resource
                double costPerBw = 0.0;                 // the cost of
using bw in this resource
                LinkedList<Storage> storageList = new
LinkedList<Storage>();    //we are not adding SAN devices by now
                DatacenterCharacteristics characteristics = new
DatacenterCharacteristics(
                                arch, os, vmm, hostList, time_zone,
cost, costPerMem,
                                costPerStorage, costPerBw);
                // 6. Finally, we need to create a PowerDatacenter
object.
                Datacenter datacenter = null;
                try {
                        datacenter = new Datacenter(name,
characteristics, new VmAllocationPolicySimple(hostList), storageList,
0);
                } catch (Exception e) {
                        e.printStackTrace();
                }
                return datacenter;
        }
        //We strongly encourage users to develop their own broker
policies, to submit vms and cloudlets according
        //to the specific rules of the simulated scenario
        private static DatacenterBroker createBroker(){
                DatacenterBroker broker = null;
                try {
                        broker = new DatacenterBroker("Broker");
                } catch (Exception e) {
                        e.printStackTrace();
                        return null;
                }
                return broker;
        }
        /**
         * Prints the Cloudlet objects
         * @param list  list of Cloudlets
         */
        private static void printCloudletList(List<Cloudlet> list) {
                int size = list.size();
                Cloudlet cloudlet;
                String indent = "    ";
                Log.printLine();
                Log.printLine("========== OUTPUT ==========");
                Log.printLine("Cloudlet ID" + indent + "STATUS" +
indent +
                                "Data center ID" + indent + "VM ID" +
indent + "Time" + indent + "Start Time" + indent + "Finish Time");
                for (int i = 0; i < size; i++) {
                        cloudlet = list.get(i);
                        Log.print(indent + cloudlet.getCloudletId() +
indent + indent);
                        if (cloudlet.getCloudletStatus() ==
Cloudlet.SUCCESS){
                                Log.print("SUCCESS");
                                DecimalFormat dft = new
DecimalFormat("###.##");
                                Log.printLine( indent + indent +
cloudlet.getResourceId() + indent + indent + indent +
cloudlet.getVmId() +
                                                indent + indent +
dft.format(cloudlet.getActualCPUTime()) + indent + indent +
dft.format(cloudlet.getExecStartTime())+
                                                indent + indent +
dft.format(cloudlet.getFinishTime()));
                        }
                }
        }
}
3.Create a simulation showing how to create two datacenters with one host each and run cloudlets
of two users with network topology on them.

/*
* Title: CloudSim Toolkit
* Description: CloudSim (Cloud Simulation) Toolkit for Modeling and
Simulation
* of Clouds
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
*
*
*/

package org.cloudbus.cloudsim.examples.network;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.NetworkTopology;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerSpaceShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;

/**
* A simple example showing how to create
* two datacenters with one host each and
* run cloudlets of two users with network
* topology on them.
*/
public class NetworkExample3 {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList1;
private static List<Cloudlet> cloudletList2;

/** The vmlist. */

 private static List<Vm> vmlist1;
private static List<Vm> vmlist2;

/**
* Creates main() to run this example
*/
public static void main(String[] args) {

Log.printLine("Starting NetworkExample3...");

try {
// First step: Initialize the CloudSim package. It
should be called
// before creating any entities.
int num_user = 2; // number of cloud users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events

// Initialize the CloudSim library

CloudSim.init(num_user, calendar, trace_flag);

// Second step: Create Datacenters

//Datacenters are the resource providers in
CloudSim. We need at list one of them to run a CloudSim simulation
Datacenter datacenter0 =
createDatacenter("Datacenter_0");
Datacenter datacenter1 =
createDatacenter("Datacenter_1");

//Third step: Create Brokers

DatacenterBroker broker1 = createBroker(1);
int brokerId1 = broker1.getId();

DatacenterBroker broker2 = createBroker(2);

int brokerId2 = broker2.getId();

//Fourth step: Create one virtual machine for each

broker/user
vmlist1 = new ArrayList<Vm>();
vmlist2 = new ArrayList<Vm>();

//VM description
int vmid = 0;
long size = 10000; //image size (MB)
int mips = 250;
int ram = 512; //vm memory (MB)
long bw = 1000;
int pesNumber = 1; //number of cpus
String vmm = "Xen"; //VMM name

//create two VMs: the first one belongs to user1

Vm vm1 = new Vm(vmid, brokerId1, mips, pesNumber,
ram, bw, size, vmm, new CloudletSchedulerTimeShared());

//the second VM: this one belongs to user2

 Vm vm2 = new Vm(vmid, brokerId2, mips, pesNumber,
ram, bw, size, vmm, new CloudletSchedulerTimeShared());

//add the VMs to the vmlists

vmlist1.add(vm1);
vmlist2.add(vm2);

//submit vm list to the broker

broker1.submitVmList(vmlist1);
broker2.submitVmList(vmlist2);

//Fifth step: Create two Cloudlets

cloudletList1 = new ArrayList<Cloudlet>();
cloudletList2 = new ArrayList<Cloudlet>();

//Cloudlet properties
int id = 0;
long length = 40000;
long fileSize = 300;
long outputSize = 300;
UtilizationModel utilizationModel = new
UtilizationModelFull();

Cloudlet cloudlet1 = new Cloudlet(id, length,

pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet1.setUserId(brokerId1);

Cloudlet cloudlet2 = new Cloudlet(id, length,

pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet2.setUserId(brokerId2);

//add the cloudlets to the lists: each cloudlet

belongs to one user
cloudletList1.add(cloudlet1);
cloudletList2.add(cloudlet2);

//submit cloudlet list to the brokers

broker1.submitCloudletList(cloudletList1);
broker2.submitCloudletList(cloudletList2);

//Sixth step: configure network

//load the network topology file

NetworkTopology.buildNetworkTopology("topology.brite");

//maps CloudSim entities to BRITE entities

//Datacenter0 will correspond to BRITE node 0
int briteNode=0;

NetworkTopology.mapNode(datacenter0.getId(),briteNode);

//Datacenter1 will correspond to BRITE node 2

 briteNode=2;

NetworkTopology.mapNode(datacenter1.getId(),briteNode);

//Broker1 will correspond to BRITE node 3

briteNode=3;

NetworkTopology.mapNode(broker1.getId(),briteNode);

//Broker2 will correspond to BRITE node 4

briteNode=4;

NetworkTopology.mapNode(broker2.getId(),briteNode);

// Sixth step: Starts the simulation

CloudSim.startSimulation();

// Final step: Print results when simulation is

over
List<Cloudlet> newList1 =
broker1.getCloudletReceivedList();
List<Cloudlet> newList2 =
broker2.getCloudletReceivedList();

CloudSim.stopSimulation();

Log.print("=============> User "+brokerId1+"

");
printCloudletList(newList1);

Log.print("=============> User "+brokerId2+"

");
printCloudletList(newList2);

//Print the debt of each user to each datacenter

datacenter0.printDebts();
datacenter1.printDebts();

Log.printLine("NetworkExample3 finished!");
}
catch (Exception e) {
e.printStackTrace();
Log.printLine("The simulation has been terminated
due to an unexpected error");
}
}

private static Datacenter createDatacenter(String name){

// Here are the steps needed to create a PowerDatacenter:

// 1. We need to create a list to store
// our machine
List<Host> hostList = new ArrayList<Host>();

// 2. A Machine contains one or more PEs or CPUs/Cores.

 // In this example, it will have only one core.
List<Pe> peList = new ArrayList<Pe>();

int mips = 1000;

// 3. Create PEs and add these into a list.

peList.add(new Pe(0, new PeProvisionerSimple(mips))); //
need to store Pe id and MIPS Rating

//4. Create Host with its id and list of PEs and add them
to the list of machines
int hostId=0;
int ram = 2048; //host memory (MB)
long storage = 1000000; //host storage
int bw = 10000;

//in this example, the VMAllocatonPolicy in use is

SpaceShared. It means that only one VM
//is allowed to run on each Pe. As each Host has only one
Pe, only one VM can run on each Host.
hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList,
new VmSchedulerSpaceShared(peList)
)
); // This is our machine

// 5. Create a DatacenterCharacteristics object that

stores the
// properties of a data center: architecture, OS, list
of
// Machines, allocation policy: time- or space-shared,
time zone
// and its price (G$/Pe time unit).
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this
resource located
double cost = 3.0; // the cost of using
processing in this resource
double costPerMem = 0.05; // the cost of using
memory in this resource
double costPerStorage = 0.001; // the cost of using
storage in this resource
double costPerBw = 0.0; // the cost of
using bw in this resource
LinkedList<Storage> storageList = new
LinkedList<Storage>(); //we are not adding SAN devices by now
 DatacenterCharacteristics characteristics = new
DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost,
costPerMem,
costPerStorage, costPerBw);

// 6. Finally, we need to create a PowerDatacenter

object.
Datacenter datacenter = null;
try {
datacenter = new Datacenter(name, characteristics,
new VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}

//We strongly encourage users to develop their own broker

policies, to submit vms and cloudlets according
//to the specific rules of the simulated scenario
private static DatacenterBroker createBroker(int id){

DatacenterBroker broker = null;

try {
broker = new DatacenterBroker("Broker"+id);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}

/**
* Prints the Cloudlet objects
* @param list list of Cloudlets
*/
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent
+
"Data center ID" + indent + "VM ID" +
indent + "Time" + indent + "Start Time" + indent + "Finish Time");

for (int i = 0; i < size; i++) {

cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() +
indent + indent);
 if (cloudlet.getCloudletStatus() ==
Cloudlet.SUCCESS){
Log.print("SUCCESS");

DecimalFormat dft = new

DecimalFormat("###.##");
Log.printLine( indent + indent +
cloudlet.getResourceId() + indent + indent + indent +
cloudlet.getVmId() +
indent + indent +
dft.format(cloudlet.getActualCPUTime()) + indent + indent +
dft.format(cloudlet.getExecStartTime())+
indent + indent +
dft.format(cloudlet.getFinishTime()));
}
}

}
}

4. Create a simulation showing how to create two datacenters with one host each and run two
cloudlets on them.

package org.cloudbus.cloudsim.examples;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerTimeShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;

/**
* A simple example showing how to create
* a datacenter with two hosts and run two
* cloudlets on it. The cloudlets run in
* VMs with different MIPS requirements.
* The cloudlets will take different time
* to complete the execution depending on
* the requested VM performance.
*/
public class CloudSimExample3 {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList;

/** The vmlist. */

private static List<Vm> vmlist;

/**
* Creates main() to run this example
*/
public static void main(String[] args) {

Log.printLine("Starting CloudSimExample3...");

try {
// First step: Initialize the CloudSim package. It
should be called
// before creating any entities.
int num_user = 1; // number of cloud users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events

// Initialize the CloudSim library

CloudSim.init(num_user, calendar, trace_flag);

// Second step: Create Datacenters

//Datacenters are the resource providers in CloudSim.
We need at list one of them to run a CloudSim simulation
@SuppressWarnings("unused")
Datacenter datacenter0 =
createDatacenter("Datacenter_0");

//Third step: Create Broker

DatacenterBroker broker = createBroker();
int brokerId = broker.getId();
 //Fourth step: Create one virtual machine
vmlist = new ArrayList<Vm>();

//VM description
int vmid = 0;
int mips = 250;
long size = 10000; //image size (MB)
int ram = 2048; //vm memory (MB)
long bw = 1000;
int pesNumber = 1; //number of cpus
String vmm = "Xen"; //VMM name

//create two VMs

Vm vm1 = new Vm(vmid, brokerId, mips, pesNumber, ram,
bw, size, vmm, new CloudletSchedulerTimeShared());

//the second VM will have twice the priority of VM1

and so will receive twice CPU time
vmid++;
Vm vm2 = new Vm(vmid, brokerId, mips * 2, pesNumber,
ram, bw, size, vmm, new CloudletSchedulerTimeShared());

//add the VMs to the vmList

vmlist.add(vm1);
vmlist.add(vm2);

//submit vm list to the broker

broker.submitVmList(vmlist);

//Fifth step: Create two Cloudlets

cloudletList = new ArrayList<Cloudlet>();

//Cloudlet properties
int id = 0;
long length = 40000;
long fileSize = 300;
long outputSize = 300;
UtilizationModel utilizationModel = new
UtilizationModelFull();

Cloudlet cloudlet1 = new Cloudlet(id, length,

pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet1.setUserId(brokerId);

id++;
Cloudlet cloudlet2 = new Cloudlet(id, length,
pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet2.setUserId(brokerId);

//add the cloudlets to the list

cloudletList.add(cloudlet1);
 cloudletList.add(cloudlet2);

//submit cloudlet list to the broker

broker.submitCloudletList(cloudletList);

//bind the cloudlets to the vms. This way, the broker

// will submit the bound cloudlets only to the
specific VM

broker.bindCloudletToVm(cloudlet1.getCloudletId(),vm1.getId());

broker.bindCloudletToVm(cloudlet2.getCloudletId(),vm2.getId());

// Sixth step: Starts the simulation

CloudSim.startSimulation();

// Final step: Print results when simulation is over

List<Cloudlet> newList =
broker.getCloudletReceivedList();

CloudSim.stopSimulation();

printCloudletList(newList);

Log.printLine("CloudSimExample3 finished!");
}
catch (Exception e) {
e.printStackTrace();
Log.printLine("The simulation has been terminated due
to an unexpected error");
}
}

private static Datacenter createDatacenter(String name){

// Here are the steps needed to create a PowerDatacenter:

// 1. We need to create a list to store
// our machine
List<Host> hostList = new ArrayList<Host>();

// 2. A Machine contains one or more PEs or CPUs/Cores.

// In this example, it will have only one core.
List<Pe> peList = new ArrayList<Pe>();

int mips = 1000;

// 3. Create PEs and add these into a list.

peList.add(new Pe(0, new PeProvisionerSimple(mips))); //
need to store Pe id and MIPS Rating

//4. Create Hosts with its id and list of PEs and add them
to the list of machines
int hostId=0;
 int ram = 2048; //host memory (MB)
long storage = 1000000; //host storage
int bw = 10000;

hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList,
new VmSchedulerTimeShared(peList)
)
); // This is our first machine

//create another machine in the Data center

List<Pe> peList2 = new ArrayList<Pe>();

peList2.add(new Pe(0, new PeProvisionerSimple(mips)));

hostId++;

hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList2,
new VmSchedulerTimeShared(peList2)
)
); // This is our second machine

// 5. Create a DatacenterCharacteristics object that stores

the
// properties of a data center: architecture, OS, list of
// Machines, allocation policy: time- or space-shared,
time zone
// and its price (G$/Pe time unit).
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource
located
double cost = 3.0; // the cost of using
processing in this resource
double costPerMem = 0.05; // the cost of using memory
in this resource
double costPerStorage = 0.001; // the cost of using
storage in this resource
double costPerBw = 0.0; // the cost of using
bw in this resource
 LinkedList<Storage> storageList = new LinkedList<Storage>();
//we are not adding SAN devices by now

DatacenterCharacteristics characteristics = new

DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost, costPerMem,
costPerStorage, costPerBw);

// 6. Finally, we need to create a PowerDatacenter object.

Datacenter datacenter = null;
try {
datacenter = new Datacenter(name, characteristics, new
VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}

//We strongly encourage users to develop their own broker

policies, to submit vms and cloudlets according
//to the specific rules of the simulated scenario
private static DatacenterBroker createBroker(){

DatacenterBroker broker = null;

try {
broker = new DatacenterBroker("Broker");
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}

/**
* Prints the Cloudlet objects
* @param list list of Cloudlets
*/
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent +
"Data center ID" + indent + "VM ID" + indent +
"Time" + indent + "Start Time" + indent + "Finish Time");

DecimalFormat dft = new DecimalFormat("###.##");

for (int i = 0; i < size; i++) {
cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() + indent +
indent);
 if (cloudlet.getCloudletStatus() == Cloudlet.SUCCESS){
Log.print("SUCCESS");

Log.printLine( indent + indent +

cloudlet.getResourceId() + indent + indent + indent +
cloudlet.getVmId() +
indent + indent +
dft.format(cloudlet.getActualCPUTime()) + indent + indent +
dft.format(cloudlet.getExecStartTime())+
indent + indent +
dft.format(cloudlet.getFinishTime()));
}
}
}
}
 5. Create a simulation showing how to create two datacenters with one host each and run
cloudlets of two users on them.

package org.cloudbus.cloudsim.examples;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerSpaceShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;

/**
* A simple example showing how to create
* two datacenters with one host each and
* run two cloudlets on them.
*/
public class CloudSimExample4 {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList;

/** The vmlist. */

private static List<Vm> vmlist;

/**
* Creates main() to run this example
*/
public static void main(String[] args) {

Log.printLine("Starting CloudSimExample4...");
 try {
// First step: Initialize the CloudSim package. It
should be called
// before creating any entities.
int num_user = 1; // number of cloud users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events

// Initialize the GridSim library

CloudSim.init(num_user, calendar, trace_flag);

// Second step: Create Datacenters

//Datacenters are the resource providers in CloudSim.
We need at list one of them to run a CloudSim simulation
@SuppressWarnings("unused")
Datacenter datacenter0 =
createDatacenter("Datacenter_0");
@SuppressWarnings("unused")
Datacenter datacenter1 =
createDatacenter("Datacenter_1");

//Third step: Create Broker

DatacenterBroker broker = createBroker();
int brokerId = broker.getId();

//Fourth step: Create one virtual machine

vmlist = new ArrayList<Vm>();

//VM description
int vmid = 0;
int mips = 250;
long size = 10000; //image size (MB)
int ram = 512; //vm memory (MB)
long bw = 1000;
int pesNumber = 1; //number of cpus
String vmm = "Xen"; //VMM name

//create two VMs

Vm vm1 = new Vm(vmid, brokerId, mips, pesNumber, ram,
bw, size, vmm, new CloudletSchedulerTimeShared());

vmid++;
Vm vm2 = new Vm(vmid, brokerId, mips, pesNumber, ram,
bw, size, vmm, new CloudletSchedulerTimeShared());

//add the VMs to the vmList

vmlist.add(vm1);
vmlist.add(vm2);

//submit vm list to the broker

broker.submitVmList(vmlist);

//Fifth step: Create two Cloudlets

cloudletList = new ArrayList<Cloudlet>();
 //Cloudlet properties
int id = 0;
long length = 40000;
long fileSize = 300;
long outputSize = 300;
UtilizationModel utilizationModel = new
UtilizationModelFull();

Cloudlet cloudlet1 = new Cloudlet(id, length,

pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet1.setUserId(brokerId);

id++;
Cloudlet cloudlet2 = new Cloudlet(id, length,
pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet2.setUserId(brokerId);

//add the cloudlets to the list

cloudletList.add(cloudlet1);
cloudletList.add(cloudlet2);

//submit cloudlet list to the broker

broker.submitCloudletList(cloudletList);

//bind the cloudlets to the vms. This way, the broker

// will submit the bound cloudlets only to the
specific VM

broker.bindCloudletToVm(cloudlet1.getCloudletId(),vm1.getId());

broker.bindCloudletToVm(cloudlet2.getCloudletId(),vm2.getId());

// Sixth step: Starts the simulation

CloudSim.startSimulation();

// Final step: Print results when simulation is over

List<Cloudlet> newList =
broker.getCloudletReceivedList();

CloudSim.stopSimulation();

printCloudletList(newList);

Log.printLine("CloudSimExample4 finished!");
}
catch (Exception e) {
e.printStackTrace();
Log.printLine("The simulation has been terminated due
to an unexpected error");
}
 }

private static Datacenter createDatacenter(String name){

// Here are the steps needed to create a PowerDatacenter:

// 1. We need to create a list to store
// our machine
List<Host> hostList = new ArrayList<Host>();

// 2. A Machine contains one or more PEs or CPUs/Cores.

// In this example, it will have only one core.
List<Pe> peList = new ArrayList<Pe>();

int mips = 1000;

// 3. Create PEs and add these into a list.

peList.add(new Pe(0, new PeProvisionerSimple(mips))); //
need to store Pe id and MIPS Rating

//4. Create Host with its id and list of PEs and add them to
the list of machines
int hostId=0;
int ram = 2048; //host memory (MB)
long storage = 1000000; //host storage
int bw = 10000;

//in this example, the VMAllocatonPolicy in use is

SpaceShared. It means that only one VM
//is allowed to run on each Pe. As each Host has only one
Pe, only one VM can run on each Host.
hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList,
new VmSchedulerSpaceShared(peList)
)
); // This is our first machine

// 5. Create a DatacenterCharacteristics object that stores

the
// properties of a data center: architecture, OS, list of
// Machines, allocation policy: time- or space-shared,
time zone
// and its price (G$/Pe time unit).
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource
located
double cost = 3.0; // the cost of using
processing in this resource
 double costPerMem = 0.05; // the cost of using memory
in this resource
double costPerStorage = 0.001; // the cost of using
storage in this resource
double costPerBw = 0.0; // the cost of using
bw in this resource
LinkedList<Storage> storageList = new LinkedList<Storage>();
//we are not adding SAN devices by now

DatacenterCharacteristics characteristics = new

DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost,
costPerMem, costPerStorage, costPerBw);

// 6. Finally, we need to create a PowerDatacenter object.

Datacenter datacenter = null;
try {
datacenter = new Datacenter(name, characteristics, new
VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}

//We strongly encourage users to develop their own broker

policies, to submit vms and cloudlets according
//to the specific rules of the simulated scenario
private static DatacenterBroker createBroker(){

DatacenterBroker broker = null;

try {
broker = new DatacenterBroker("Broker");
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}

/**
* Prints the Cloudlet objects
* @param list list of Cloudlets
*/
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent +
 "Data center ID" + indent + "VM ID" + indent +
"Time" + indent + "Start Time" + indent + "Finish Time");

DecimalFormat dft = new DecimalFormat("###.##");

for (int i = 0; i < size; i++) {
cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() + indent +
indent);

if (cloudlet.getCloudletStatus() == Cloudlet.SUCCESS){
Log.print("SUCCESS");

Log.printLine( indent + indent +

cloudlet.getResourceId() + indent + indent + indent +
cloudlet.getVmId() +
indent + indent +
dft.format(cloudlet.getActualCPUTime()) + indent + indent +
dft.format(cloudlet.getExecStartTime())+
indent + indent +
dft.format(cloudlet.getFinishTime()));
}
}

}
}
 6. An example showing how to create scalable simulations.

package org.cloudbus.cloudsim.examples;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerTimeShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;

/**
* An example showing how to create
* scalable simulations.
*/
public class CloudSimExample6 {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList;

/** The vmlist. */

private static List<Vm> vmlist;

private static List<Vm> createVM(int userId, int vms) {

//Creates a container to store VMs. This list is passed to

the broker later
LinkedList<Vm> list = new LinkedList<Vm>();

//VM Parameters
long size = 10000; //image size (MB)
int ram = 512; //vm memory (MB)
int mips = 1000;
long bw = 1000;
int pesNumber = 1; //number of cpus
 String vmm = "Xen"; //VMM name

//create VMs
Vm[] vm = new Vm[vms];

for(int i=0;i<vms;i++){
vm[i] = new Vm(i, userId, mips, pesNumber, ram, bw,
size, vmm, new CloudletSchedulerTimeShared());
//for creating a VM with a space shared scheduling
policy for cloudlets:
//vm[i] = Vm(i, userId, mips, pesNumber, ram, bw,
size, priority, vmm, new CloudletSchedulerSpaceShared());

list.add(vm[i]);
}

return list;
}

private static List<Cloudlet> createCloudlet(int userId, int

cloudlets){
// Creates a container to store Cloudlets
LinkedList<Cloudlet> list = new LinkedList<Cloudlet>();

//cloudlet parameters
long length = 1000;
long fileSize = 300;
long outputSize = 300;
int pesNumber = 1;
UtilizationModel utilizationModel = new
UtilizationModelFull();

Cloudlet[] cloudlet = new Cloudlet[cloudlets];

for(int i=0;i<cloudlets;i++){
cloudlet[i] = new Cloudlet(i, length, pesNumber,
fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
// setting the owner of these Cloudlets
cloudlet[i].setUserId(userId);
list.add(cloudlet[i]);
}

return list;
}

////////////////////////// STATIC METHODS ///////////////////////

/**
* Creates main() to run this example
*/
public static void main(String[] args) {
Log.printLine("Starting CloudSimExample6...");
 try {
// First step: Initialize the CloudSim package. It
should be called
// before creating any entities.
int num_user = 1; // number of grid users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events

// Initialize the CloudSim library

CloudSim.init(num_user, calendar, trace_flag);

// Second step: Create Datacenters

//Datacenters are the resource providers in CloudSim.
We need at list one of them to run a CloudSim simulation
@SuppressWarnings("unused")
Datacenter datacenter0 =
createDatacenter("Datacenter_0");
@SuppressWarnings("unused")
Datacenter datacenter1 =
createDatacenter("Datacenter_1");

//Third step: Create Broker

DatacenterBroker broker = createBroker();
int brokerId = broker.getId();

//Fourth step: Create VMs and Cloudlets and send them

to broker
vmlist = createVM(brokerId,20); //creating 20 vms
cloudletList = createCloudlet(brokerId,40); //
creating 40 cloudlets

broker.submitVmList(vmlist);
broker.submitCloudletList(cloudletList);

// Fifth step: Starts the simulation

CloudSim.startSimulation();

// Final step: Print results when simulation is over

List<Cloudlet> newList =
broker.getCloudletReceivedList();

CloudSim.stopSimulation();

printCloudletList(newList);

Log.printLine("CloudSimExample6 finished!");
}
catch (Exception e)
{
e.printStackTrace();
Log.printLine("The simulation has been terminated due
to an unexpected error");
}
}
 private static Datacenter createDatacenter(String name){

// Here are the steps needed to create a PowerDatacenter:

// 1. We need to create a list to store one or more
// Machines
List<Host> hostList = new ArrayList<Host>();

// 2. A Machine contains one or more PEs or CPUs/Cores.

Therefore, should
// create a list to store these PEs before creating
// a Machine.
List<Pe> peList1 = new ArrayList<Pe>();

int mips = 1000;

// 3. Create PEs and add these into the list.

//for a quad-core machine, a list of 4 PEs is required:
peList1.add(new Pe(0, new PeProvisionerSimple(mips))); //
need to store Pe id and MIPS Rating
peList1.add(new Pe(1, new PeProvisionerSimple(mips)));
peList1.add(new Pe(2, new PeProvisionerSimple(mips)));
peList1.add(new Pe(3, new PeProvisionerSimple(mips)));

//Another list, for a dual-core machine

List<Pe> peList2 = new ArrayList<Pe>();

peList2.add(new Pe(0, new PeProvisionerSimple(mips)));

peList2.add(new Pe(1, new PeProvisionerSimple(mips)));

//4. Create Hosts with its id and list of PEs and add them
to the list of machines
int hostId=0;
int ram = 2048; //host memory (MB)
long storage = 1000000; //host storage
int bw = 10000;

hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList1,
new VmSchedulerTimeShared(peList1)
)
); // This is our first machine

hostId++;

hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
 storage,
peList2,
new VmSchedulerTimeShared(peList2)
)
); // Second machine

//To create a host with a space-shared allocation policy for

PEs to VMs:
//hostList.add(
// new Host(
// hostId,
// new CpuProvisionerSimple(peList1),
// new RamProvisionerSimple(ram),
// new BwProvisionerSimple(bw),
// storage,
// new VmSchedulerSpaceShared(peList1)
// )
// );

//To create a host with a oportunistic space-shared

allocation policy for PEs to VMs:
//hostList.add(
// new Host(
// hostId,
// new CpuProvisionerSimple(peList1),
// new RamProvisionerSimple(ram),
// new BwProvisionerSimple(bw),
// storage,
// new VmSchedulerOportunisticSpaceShared(peList1)
// )
// );

// 5. Create a DatacenterCharacteristics object that stores

the
// properties of a data center: architecture, OS, list of
// Machines, allocation policy: time- or space-shared,
time zone
// and its price (G$/Pe time unit).
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource
located
double cost = 3.0; // the cost of using
processing in this resource
double costPerMem = 0.05; // the cost of using memory
in this resource
double costPerStorage = 0.1; // the cost of using
storage in this resource
double costPerBw = 0.1; // the cost of using
bw in this resource
LinkedList<Storage> storageList = new LinkedList<Storage>();
//we are not adding SAN devices by now
 DatacenterCharacteristics characteristics = new
DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost, costPerMem,
costPerStorage, costPerBw);

// 6. Finally, we need to create a PowerDatacenter object.

Datacenter datacenter = null;
try {
datacenter = new Datacenter(name, characteristics, new
VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}

//We strongly encourage users to develop their own broker

policies, to submit vms and cloudlets according
//to the specific rules of the simulated scenario
private static DatacenterBroker createBroker(){

DatacenterBroker broker = null;

try {
broker = new DatacenterBroker("Broker");
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}

/**
* Prints the Cloudlet objects
* @param list list of Cloudlets
*/
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent +
"Data center ID" + indent + "VM ID" + indent +
indent + "Time" + indent + "Start Time" + indent + "Finish Time");

DecimalFormat dft = new DecimalFormat("###.##");

for (int i = 0; i < size; i++) {
cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() + indent +
indent);
 if (cloudlet.getCloudletStatus() == Cloudlet.SUCCESS){
Log.print("SUCCESS");

Log.printLine( indent + indent +

cloudlet.getResourceId() + indent + indent + indent +
cloudlet.getVmId() +
indent + indent + indent +
dft.format(cloudlet.getActualCPUTime()) +
indent + indent +
dft.format(cloudlet.getExecStartTime())+ indent + indent + indent +
dft.format(cloudlet.getFinishTime()));
}
}

}
}
 7. An example showing how to pause and resume the simulation, and create simulation entities
(a Datacenter Broker in this example) dynamically.

package org.cloudbus.cloudsim.examples;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerTimeShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;

/**
* An example showing how to pause and resume the simulation,
* and create simulation entities (a DatacenterBroker in this example)
* dynamically.
*/
public class CloudSimExample7 {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList;

/** The vmlist. */

private static List<Vm> vmlist;

private static List<Vm> createVM(int userId, int vms, int

idShift) {
//Creates a container to store VMs. This list is passed to
the broker later
LinkedList<Vm> list = new LinkedList<Vm>();

//VM Parameters
long size = 10000; //image size (MB)
int ram = 512; //vm memory (MB)
int mips = 250;
 long bw = 1000;
int pesNumber = 1; //number of cpus
String vmm = "Xen"; //VMM name

//create VMs
Vm[] vm = new Vm[vms];

for(int i=0;i<vms;i++){
vm[i] = new Vm(idShift + i, userId, mips, pesNumber,
ram, bw, size, vmm, new CloudletSchedulerTimeShared());
list.add(vm[i]);
}

return list;
}

private static List<Cloudlet> createCloudlet(int userId, int

cloudlets, int idShift){
// Creates a container to store Cloudlets
LinkedList<Cloudlet> list = new LinkedList<Cloudlet>();

//cloudlet parameters
long length = 40000;
long fileSize = 300;
long outputSize = 300;
int pesNumber = 1;
UtilizationModel utilizationModel = new
UtilizationModelFull();

Cloudlet[] cloudlet = new Cloudlet[cloudlets];

for(int i=0;i<cloudlets;i++){
cloudlet[i] = new Cloudlet(idShift + i, length,
pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
// setting the owner of these Cloudlets
cloudlet[i].setUserId(userId);
list.add(cloudlet[i]);
}

return list;
}

////////////////////////// STATIC METHODS ///////////////////////

/**
* Creates main() to run this example
*/
public static void main(String[] args) {
Log.printLine("Starting CloudSimExample7...");

try {
 // First step: Initialize the CloudSim package. It
should be called
// before creating any entities.
int num_user = 2; // number of grid users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events

// Initialize the CloudSim library

CloudSim.init(num_user, calendar, trace_flag);

// Second step: Create Datacenters

//Datacenters are the resource providers in CloudSim.
We need at list one of them to run a CloudSim simulation
@SuppressWarnings("unused")
Datacenter datacenter0 =
createDatacenter("Datacenter_0");
@SuppressWarnings("unused")
Datacenter datacenter1 =
createDatacenter("Datacenter_1");

//Third step: Create Broker

DatacenterBroker broker = createBroker("Broker_0");
int brokerId = broker.getId();

//Fourth step: Create VMs and Cloudlets and send them

to broker
vmlist = createVM(brokerId, 5, 0); //creating 5 vms
cloudletList = createCloudlet(brokerId, 10, 0); //
creating 10 cloudlets

broker.submitVmList(vmlist);
broker.submitCloudletList(cloudletList);

// A thread that will create a new broker at 200 clock

time
Runnable monitor = new Runnable() {
@Override
public void run() {
CloudSim.pauseSimulation(200);
while (true) {
if (CloudSim.isPaused()) {
break;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

Log.printLine("\n\n\n" + CloudSim.clock() +
": The simulation is paused for 5 sec \n\n");

try {
Thread.sleep(5000);
 } catch (InterruptedException e) {
e.printStackTrace();
}

DatacenterBroker broker =
createBroker("Broker_1");
int brokerId = broker.getId();

//Create VMs and Cloudlets and send them to

broker
vmlist = createVM(brokerId, 5, 100);
//creating 5 vms
cloudletList = createCloudlet(brokerId, 10,
100); // creating 10 cloudlets

broker.submitVmList(vmlist);
broker.submitCloudletList(cloudletList);

CloudSim.resumeSimulation();
}
};

new Thread(monitor).start();
Thread.sleep(1000);

// Fifth step: Starts the simulation

CloudSim.startSimulation();

// Final step: Print results when simulation is over

List<Cloudlet> newList =
broker.getCloudletReceivedList();

CloudSim.stopSimulation();

printCloudletList(newList);

Log.printLine("CloudSimExample7 finished!");
}
catch (Exception e)
{
e.printStackTrace();
Log.printLine("The simulation has been terminated due
to an unexpected error");
}
}

private static Datacenter createDatacenter(String name){

// Here are the steps needed to create a PowerDatacenter:

// 1. We need to create a list to store one or more
// Machines
List<Host> hostList = new ArrayList<Host>();

// 2. A Machine contains one or more PEs or CPUs/Cores.

Therefore, should
 // create a list to store these PEs before creating
// a Machine.
List<Pe> peList1 = new ArrayList<Pe>();

int mips = 1000;

// 3. Create PEs and add these into the list.

//for a quad-core machine, a list of 4 PEs is required:
peList1.add(new Pe(0, new PeProvisionerSimple(mips))); //
need to store Pe id and MIPS Rating
peList1.add(new Pe(1, new PeProvisionerSimple(mips)));
peList1.add(new Pe(2, new PeProvisionerSimple(mips)));
peList1.add(new Pe(3, new PeProvisionerSimple(mips)));

//Another list, for a dual-core machine

List<Pe> peList2 = new ArrayList<Pe>();

peList2.add(new Pe(0, new PeProvisionerSimple(mips)));

peList2.add(new Pe(1, new PeProvisionerSimple(mips)));

//4. Create Hosts with its id and list of PEs and add them
to the list of machines
int hostId=0;
int ram = 16384; //host memory (MB)
long storage = 1000000; //host storage
int bw = 10000;

hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList1,
new VmSchedulerTimeShared(peList1)
)
); // This is our first machine

hostId++;

hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList2,
new VmSchedulerTimeShared(peList2)
)
); // Second machine

// 5. Create a DatacenterCharacteristics object that stores

the
// properties of a data center: architecture, OS, list of
 // Machines, allocation policy: time- or space-shared,
time zone
// and its price (G$/Pe time unit).
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource
located
double cost = 3.0; // the cost of using
processing in this resource
double costPerMem = 0.05; // the cost of using memory
in this resource
double costPerStorage = 0.1; // the cost of using
storage in this resource
double costPerBw = 0.1; // the cost of using
bw in this resource
LinkedList<Storage> storageList = new LinkedList<Storage>();
//we are not adding SAN devices by now

DatacenterCharacteristics characteristics = new

DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost, costPerMem,
costPerStorage, costPerBw);

// 6. Finally, we need to create a PowerDatacenter object.

Datacenter datacenter = null;
try {
datacenter = new Datacenter(name, characteristics, new
VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}

//We strongly encourage users to develop their own broker

policies, to submit vms and cloudlets according
//to the specific rules of the simulated scenario
private static DatacenterBroker createBroker(String name){

DatacenterBroker broker = null;

try {
broker = new DatacenterBroker(name);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}

/**
* Prints the Cloudlet objects
* @param list list of Cloudlets
 */
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent +
"Data center ID" + indent + "VM ID" + indent +
indent + "Time" + indent + "Start Time" + indent + "Finish Time");

DecimalFormat dft = new DecimalFormat("###.##");

for (int i = 0; i < size; i++) {
cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() + indent +
indent);

if (cloudlet.getCloudletStatus() == Cloudlet.SUCCESS){
Log.print("SUCCESS");

Log.printLine( indent + indent +

cloudlet.getResourceId() + indent + indent + indent +
cloudlet.getVmId() +
indent + indent + indent +
dft.format(cloudlet.getActualCPUTime()) +
indent + indent +
dft.format(cloudlet.getExecStartTime())+ indent + indent + indent +
dft.format(cloudlet.getFinishTime()));
}
}

}
}
 8. An example showing how to create simulation entities (a DatacenterBroker in this example)
in run-time using a globar manager entity (GlobalBroker).

/*
* Title: CloudSim Toolkit
* Description: CloudSim (Cloud Simulation) Toolkit for Modeling and
Simulation
* of Clouds
* Licence: GPL - http://www.gnu.org/copyleft/gpl.html
*
* Copyright (c) 2009, The University of Melbourne, Australia
*/

package org.cloudbus.cloudsim.examples;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerTimeShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.core.SimEntity;
import org.cloudbus.cloudsim.core.SimEvent;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;

/**
* An example showing how to create simulation entities
* (a DatacenterBroker in this example) in run-time using
* a globar manager entity (GlobalBroker).
*/
public class CloudSimExample8 {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList;
 /** The vmList. */
private static List<Vm> vmList;

private static List<Vm> createVM(int userId, int vms, int

idShift) {
//Creates a container to store VMs. This list is passed to
the broker later
LinkedList<Vm> list = new LinkedList<Vm>();

//VM Parameters
long size = 10000; //image size (MB)
int ram = 512; //vm memory (MB)
int mips = 250;
long bw = 1000;
int pesNumber = 1; //number of cpus
String vmm = "Xen"; //VMM name

//create VMs
Vm[] vm = new Vm[vms];

for(int i=0;i<vms;i++){
vm[i] = new Vm(idShift + i, userId, mips, pesNumber,
ram, bw, size, vmm, new CloudletSchedulerTimeShared());
list.add(vm[i]);
}

return list;
}

private static List<Cloudlet> createCloudlet(int userId, int

cloudlets, int idShift){
// Creates a container to store Cloudlets
LinkedList<Cloudlet> list = new LinkedList<Cloudlet>();

//cloudlet parameters
long length = 40000;
long fileSize = 300;
long outputSize = 300;
int pesNumber = 1;
UtilizationModel utilizationModel = new
UtilizationModelFull();

Cloudlet[] cloudlet = new Cloudlet[cloudlets];

for(int i=0;i<cloudlets;i++){
cloudlet[i] = new Cloudlet(idShift + i, length,
pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
// setting the owner of these Cloudlets
cloudlet[i].setUserId(userId);
list.add(cloudlet[i]);
}
 return list;
}

////////////////////////// STATIC METHODS ///////////////////////

/**
* Creates main() to run this example
*/
public static void main(String[] args) {
Log.printLine("Starting CloudSimExample8...");

try {
// First step: Initialize the CloudSim package. It
should be called
// before creating any entities.
int num_user = 2; // number of grid users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events

// Initialize the CloudSim library

CloudSim.init(num_user, calendar, trace_flag);

GlobalBroker globalBroker = new

GlobalBroker("GlobalBroker");

// Second step: Create Datacenters

//Datacenters are the resource providers in CloudSim.
We need at list one of them to run a CloudSim simulation
@SuppressWarnings("unused")
Datacenter datacenter0 =
createDatacenter("Datacenter_0");
@SuppressWarnings("unused")
Datacenter datacenter1 =
createDatacenter("Datacenter_1");

//Third step: Create Broker

DatacenterBroker broker = createBroker("Broker_0");
int brokerId = broker.getId();

//Fourth step: Create VMs and Cloudlets and send them

to broker
vmList = createVM(brokerId, 5, 0); //creating 5 vms
cloudletList = createCloudlet(brokerId, 10, 0); //
creating 10 cloudlets

broker.submitVmList(vmList);
broker.submitCloudletList(cloudletList);

// Fifth step: Starts the simulation

CloudSim.startSimulation();

// Final step: Print results when simulation is over

List<Cloudlet> newList =
broker.getCloudletReceivedList();
newList.addAll(globalBroker.getBroker().getCloudletReceivedList());

CloudSim.stopSimulation();

printCloudletList(newList);

Log.printLine("CloudSimExample8 finished!");
}
catch (Exception e)
{
e.printStackTrace();
Log.printLine("The simulation has been terminated due
to an unexpected error");
}
}

private static Datacenter createDatacenter(String name){

// Here are the steps needed to create a PowerDatacenter:

// 1. We need to create a list to store one or more
// Machines
List<Host> hostList = new ArrayList<Host>();

// 2. A Machine contains one or more PEs or CPUs/Cores.

Therefore, should
// create a list to store these PEs before creating
// a Machine.
List<Pe> peList1 = new ArrayList<Pe>();

int mips = 1000;

// 3. Create PEs and add these into the list.

//for a quad-core machine, a list of 4 PEs is required:
peList1.add(new Pe(0, new PeProvisionerSimple(mips))); //
need to store Pe id and MIPS Rating
peList1.add(new Pe(1, new PeProvisionerSimple(mips)));
peList1.add(new Pe(2, new PeProvisionerSimple(mips)));
peList1.add(new Pe(3, new PeProvisionerSimple(mips)));

//Another list, for a dual-core machine

List<Pe> peList2 = new ArrayList<Pe>();

peList2.add(new Pe(0, new PeProvisionerSimple(mips)));

peList2.add(new Pe(1, new PeProvisionerSimple(mips)));

//4. Create Hosts with its id and list of PEs and add them
to the list of machines
int hostId=0;
int ram = 16384; //host memory (MB)
long storage = 1000000; //host storage
int bw = 10000;

hostList.add(
 new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList1,
new VmSchedulerTimeShared(peList1)
)
); // This is our first machine

hostId++;

hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList2,
new VmSchedulerTimeShared(peList2)
)
); // Second machine

// 5. Create a DatacenterCharacteristics object that stores

the
// properties of a data center: architecture, OS, list of
// Machines, allocation policy: time- or space-shared,
time zone
// and its price (G$/Pe time unit).
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource
located
double cost = 3.0; // the cost of using
processing in this resource
double costPerMem = 0.05; // the cost of using memory
in this resource
double costPerStorage = 0.1; // the cost of using
storage in this resource
double costPerBw = 0.1; // the cost of using
bw in this resource
LinkedList<Storage> storageList = new LinkedList<Storage>();
//we are not adding SAN devices by now

DatacenterCharacteristics characteristics = new

DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost, costPerMem,
costPerStorage, costPerBw);

// 6. Finally, we need to create a PowerDatacenter object.

Datacenter datacenter = null;
try {
 datacenter = new Datacenter(name, characteristics, new
VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}

//We strongly encourage users to develop their own broker

policies, to submit vms and cloudlets according
//to the specific rules of the simulated scenario
private static DatacenterBroker createBroker(String name){

DatacenterBroker broker = null;

try {
broker = new DatacenterBroker(name);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}

/**
* Prints the Cloudlet objects
* @param list list of Cloudlets
*/
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent +
"Data center ID" + indent + "VM ID" + indent +
indent + "Time" + indent + "Start Time" + indent + "Finish Time");

DecimalFormat dft = new DecimalFormat("###.##");

for (int i = 0; i < size; i++) {
cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() + indent +
indent);

if (cloudlet.getCloudletStatus() == Cloudlet.SUCCESS){
Log.print("SUCCESS");

Log.printLine( indent + indent +

cloudlet.getResourceId() + indent + indent + indent +
cloudlet.getVmId() +
indent + indent + indent +
dft.format(cloudlet.getActualCPUTime()) +
 indent + indent +
dft.format(cloudlet.getExecStartTime())+ indent + indent + indent +
dft.format(cloudlet.getFinishTime()));
}
}

public static class GlobalBroker extends SimEntity {

private static final int CREATE_BROKER = 0;

private List<Vm> vmList;
private List<Cloudlet> cloudletList;
private DatacenterBroker broker;

public GlobalBroker(String name) {

super(name);
}

@Override
public void processEvent(SimEvent ev) {
switch (ev.getTag()) {
case CREATE_BROKER:
setBroker(createBroker(super.getName()+"_"));

//Create VMs and Cloudlets and send them to

broker
setVmList(createVM(getBroker().getId(), 5, 100));
//creating 5 vms

setCloudletList(createCloudlet(getBroker().getId(), 10, 100)); //

creating 10 cloudlets

broker.submitVmList(getVmList());
broker.submitCloudletList(getCloudletList());

CloudSim.resumeSimulation();

break;

default:
Log.printLine(getName() + ": unknown event
type");
break;
}
}

@Override
public void startEntity() {
Log.printLine(super.getName()+" is starting...");
schedule(getId(), 200, CREATE_BROKER);
}

@Override
public void shutdownEntity() {
 }

public List<Vm> getVmList() {

return vmList;
}

protected void setVmList(List<Vm> vmList) {

this.vmList = vmList;
}

public List<Cloudlet> getCloudletList() {

return cloudletList;
}

protected void setCloudletList(List<Cloudlet> cloudletList)

{
this.cloudletList = cloudletList;
}

public DatacenterBroker getBroker() {

return broker;
}

protected void setBroker(DatacenterBroker broker) {

this.broker = broker;
}

}
 Network Exercises

1. Create a simulation showing how to create a datacenter with one host and a network topology and
and run one cloudlet on it.

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.NetworkTopology;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerTimeShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;

/**
* A simple example showing how to create
* a datacenter with one host and a network
* topology and and run one cloudlet on it.
*/
public class NetworkExample1 {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList;

/** The vmlist. */

private static List<Vm> vmlist;

/**
* Creates main() to run this example
*/
public static void main(String[] args) {

Log.printLine("Starting NetworkExample1...");

try {
 // First step: Initialize the CloudSim package. It
should be called
// before creating any entities.
int num_user = 1; // number of cloud users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events

// Initialize the CloudSim library

CloudSim.init(num_user, calendar, trace_flag);

// Second step: Create Datacenters

//Datacenters are the resource providers in CloudSim.
We need at list one of them to run a CloudSim simulation
Datacenter datacenter0 =
createDatacenter("Datacenter_0");

//Third step: Create Broker

DatacenterBroker broker = createBroker();
int brokerId = broker.getId();

//Fourth step: Create one virtual machine

vmlist = new ArrayList<Vm>();

//VM description
int vmid = 0;
int mips = 250;
long size = 10000; //image size (MB)
int ram = 512; //vm memory (MB)
long bw = 1000;
int pesNumber = 1; //number of cpus
String vmm = "Xen"; //VMM name

//create VM
Vm vm1 = new Vm(vmid, brokerId, mips, pesNumber, ram,
bw, size, vmm, new CloudletSchedulerTimeShared());

//add the VM to the vmList

vmlist.add(vm1);

//submit vm list to the broker

broker.submitVmList(vmlist);

//Fifth step: Create one Cloudlet

cloudletList = new ArrayList<Cloudlet>();

//Cloudlet properties
int id = 0;
long length = 40000;
long fileSize = 300;
long outputSize = 300;
UtilizationModel utilizationModel = new
UtilizationModelFull();
 Cloudlet cloudlet1 = new Cloudlet(id, length,
pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet1.setUserId(brokerId);

//add the cloudlet to the list

cloudletList.add(cloudlet1);

//submit cloudlet list to the broker

broker.submitCloudletList(cloudletList);

//Sixth step: configure network

//load the network topology file

NetworkTopology.buildNetworkTopology("topology.brite");

//maps CloudSim entities to BRITE entities

//PowerDatacenter will correspond to BRITE node 0
int briteNode=0;

NetworkTopology.mapNode(datacenter0.getId(),briteNode);

//Broker will correspond to BRITE node 3

briteNode=3;
NetworkTopology.mapNode(broker.getId(),briteNode);

// Seventh step: Starts the simulation

CloudSim.startSimulation();

// Final step: Print results when simulation is over

List<Cloudlet> newList =
broker.getCloudletReceivedList();

CloudSim.stopSimulation();

printCloudletList(newList);

Log.printLine("NetworkExample1 finished!");
}
catch (Exception e) {
e.printStackTrace();
Log.printLine("The simulation has been terminated due
to an unexpected error");
}
}

private static Datacenter createDatacenter(String name){

// Here are the steps needed to create a PowerDatacenter:

// 1. We need to create a list to store
// our machine
List<Host> hostList = new ArrayList<Host>();
 // 2. A Machine contains one or more PEs or CPUs/Cores.
// In this example, it will have only one core.
List<Pe> peList = new ArrayList<Pe>();

int mips = 1000;

// 3. Create PEs and add these into a list.

peList.add(new Pe(0, new PeProvisionerSimple(mips))); //
need to store Pe id and MIPS Rating

//4. Create Host with its id and list of PEs and add them to
the list of machines
int hostId=0;
int ram = 2048; //host memory (MB)
long storage = 1000000; //host storage
int bw = 10000;

hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList,
new VmSchedulerTimeShared(peList)
)
); // This is our machine

// 5. Create a DatacenterCharacteristics object that stores

the
// properties of a data center: architecture, OS, list of
// Machines, allocation policy: time- or space-shared,
time zone
// and its price (G$/Pe time unit).
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource
located
double cost = 3.0; // the cost of using
processing in this resource
double costPerMem = 0.05; // the cost of using memory
in this resource
double costPerStorage = 0.001; // the cost of using
storage in this resource
double costPerBw = 0.0; // the cost of using
bw in this resource
LinkedList<Storage> storageList = new LinkedList<Storage>();
//we are not adding SAN devices by now

DatacenterCharacteristics characteristics = new

DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost,
costPerMem,
costPerStorage, costPerBw);
 // 6. Finally, we need to create a PowerDatacenter object.
Datacenter datacenter = null;
try {
datacenter = new Datacenter(name, characteristics, new
VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}

//We strongly encourage users to develop their own broker

policies, to submit vms and cloudlets according
//to the specific rules of the simulated scenario
private static DatacenterBroker createBroker(){

DatacenterBroker broker = null;

try {
broker = new DatacenterBroker("Broker");
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}

/**
* Prints the Cloudlet objects
* @param list list of Cloudlets
*/
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent +
"Data center ID" + indent + "VM ID" + indent +
"Time" + indent + "Start Time" + indent + "Finish Time");

for (int i = 0; i < size; i++) {

cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() + indent +
indent);

if (cloudlet.getCloudletStatus() == Cloudlet.SUCCESS){
Log.print("SUCCESS");

DecimalFormat dft = new DecimalFormat("###.##");

 Log.printLine( indent + indent +
cloudlet.getResourceId() + indent + indent + indent +
cloudlet.getVmId() +
indent + indent +
dft.format(cloudlet.getActualCPUTime()) + indent + indent +
dft.format(cloudlet.getExecStartTime())+
indent + indent +
dft.format(cloudlet.getFinishTime()));
}
}

}
}
 2. Create a simulation showing how to create two datacenters with one host and a network topology
each and run two cloudlets on them.

package org.cloudbus.cloudsim.examples.network;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.NetworkTopology;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerTimeShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;

/**
* A simple example showing how to create
* two datacenters with one host and a
* network topology each and run two cloudlets
* on them.
*/
public class NetworkExample2 {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList;

/** The vmlist. */

private static List<Vm> vmlist;

/**
* Creates main() to run this example
*/
public static void main(String[] args) {

Log.printLine("Starting NetworkExample2...");

try {
 // First step: Initialize the CloudSim package. It
should be called
// before creating any entities.
int num_user = 1; // number of cloud users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events

// Initialize the CloudSim library

CloudSim.init(num_user, calendar, trace_flag);

// Second step: Create Datacenters

//Datacenters are the resource providers in CloudSim.
We need at list one of them to run a CloudSim simulation
Datacenter datacenter0 =
createDatacenter("Datacenter_0");
Datacenter datacenter1 =
createDatacenter("Datacenter_1");

//Third step: Create Broker

DatacenterBroker broker = createBroker();
int brokerId = broker.getId();

//Fourth step: Create one virtual machine

vmlist = new ArrayList<Vm>();

//VM description
int vmid = 0;
int mips = 250;
long size = 10000; //image size (MB)
int ram = 512; //vm memory (MB)
long bw = 1000;
int pesNumber = 1; //number of cpus
String vmm = "Xen"; //VMM name

//create two VMs

Vm vm1 = new Vm(vmid, brokerId, mips, pesNumber, ram,
bw, size, vmm, new CloudletSchedulerTimeShared());

//the second VM will have twice the priority of VM1

and so will receive twice CPU time
vmid++;
Vm vm2 = new Vm(vmid, brokerId, mips, pesNumber, ram,
bw, size, vmm, new CloudletSchedulerTimeShared());

//add the VMs to the vmList

vmlist.add(vm1);
vmlist.add(vm2);

//submit vm list to the broker

broker.submitVmList(vmlist);

//Fifth step: Create two Cloudlets

cloudletList = new ArrayList<Cloudlet>();
 //Cloudlet properties
int id = 0;
long length = 40000;
long fileSize = 300;
long outputSize = 300;
UtilizationModel utilizationModel = new
UtilizationModelFull();

Cloudlet cloudlet1 = new Cloudlet(id, length,

pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet1.setUserId(brokerId);

id++;
Cloudlet cloudlet2 = new Cloudlet(id, length,
pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet2.setUserId(brokerId);

//add the cloudlets to the list

cloudletList.add(cloudlet1);
cloudletList.add(cloudlet2);

//submit cloudlet list to the broker

broker.submitCloudletList(cloudletList);

//bind the cloudlets to the vms. This way, the broker

// will submit the bound cloudlets only to the
specific VM

broker.bindCloudletToVm(cloudlet1.getCloudletId(),vm1.getId());

broker.bindCloudletToVm(cloudlet2.getCloudletId(),vm2.getId());

//Sixth step: configure network

//load the network topology file

NetworkTopology.buildNetworkTopology("topology.brite");

//maps CloudSim entities to BRITE entities

//Datacenter0 will correspond to BRITE node 0
int briteNode=0;

NetworkTopology.mapNode(datacenter0.getId(),briteNode);

//Datacenter1 will correspond to BRITE node 2

briteNode=2;

NetworkTopology.mapNode(datacenter1.getId(),briteNode);

//Broker will correspond to BRITE node 3

briteNode=3;
NetworkTopology.mapNode(broker.getId(),briteNode);
 // Sixth step: Starts the simulation
CloudSim.startSimulation();

// Final step: Print results when simulation is over

List<Cloudlet> newList =
broker.getCloudletReceivedList();

CloudSim.stopSimulation();

printCloudletList(newList);

Log.printLine("NetworkExample2 finished!");
}
catch (Exception e) {
e.printStackTrace();
Log.printLine("The simulation has been terminated due
to an unexpected error");
}
}

private static Datacenter createDatacenter(String name){

// Here are the steps needed to create a PowerDatacenter:

// 1. We need to create a list to store
// our machine
List<Host> hostList = new ArrayList<Host>();

// 2. A Machine contains one or more PEs or CPUs/Cores.

// In this example, it will have only one core.
List<Pe> peList = new ArrayList<Pe>();

int mips = 1000;

// 3. Create PEs and add these into a list

peList.add(new Pe(0, new PeProvisionerSimple(mips))); //
need to store Pe id and MIPS Rating

//4. Create Host with its id and list of PEs and add them to
the list of machines
int hostId=0;
int ram = 2048; //host memory (MB)
long storage = 1000000; //host storage
int bw = 10000;

//in this example, the VMAllocatonPolicy in use is Time

Shared with priorities. It means that VMs
//receive time shares accroding to their priority.
hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
 new BwProvisionerSimple(bw),
storage,
peList,
new VmSchedulerTimeShared(peList)
)
); // This is our machine

// 5. Create a DatacenterCharacteristics object that stores

the
// properties of a data center: architecture, OS, list of
// Machines, allocation policy: time- or space-shared,
time zone
// and its price (G$/Pe time unit).
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource
located
double cost = 3.0; // the cost of using
processing in this resource
double costPerMem = 0.05; // the cost of using memory
in this resource
double costPerStorage = 0.001; // the cost of using
storage in this resource
double costPerBw = 0.0; // the cost of using
bw in this resource
LinkedList<Storage> storageList = new LinkedList<Storage>();
//we are not adding SAN devices by now

DatacenterCharacteristics characteristics = new

DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost,
costPerMem,
costPerStorage, costPerBw);

// 6. Finally, we need to create a PowerDatacenter object.

Datacenter datacenter = null;
try {
datacenter = new Datacenter(name, characteristics, new
VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}

//We strongly encourage users to develop their own broker

policies, to submit vms and cloudlets according
//to the specific rules of the simulated scenario
private static DatacenterBroker createBroker(){

DatacenterBroker broker = null;

try {
 broker = new DatacenterBroker("Broker");
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}

/**
* Prints the Cloudlet objects
* @param list list of Cloudlets
*/
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent +
"Data center ID" + indent + "VM ID" + indent +
"Time" + indent + "Start Time" + indent + "Finish Time");

for (int i = 0; i < size; i++) {

cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() + indent +
indent);

if (cloudlet.getCloudletStatus() == Cloudlet.SUCCESS){
Log.print("SUCCESS");

DecimalFormat dft = new DecimalFormat("###.##");

Log.printLine( indent + indent +
cloudlet.getResourceId() + indent + indent + indent +
cloudlet.getVmId() +
indent + indent +
dft.format(cloudlet.getActualCPUTime()) + indent + indent +
dft.format(cloudlet.getExecStartTime())+
indent + indent +
dft.format(cloudlet.getFinishTime()));
}
}

}
}
 3. Create a simulation showing how to create two datacenters with one host each and run cloudlets
of two users with network topology on them.

package org.cloudbus.cloudsim.examples.network;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.NetworkTopology;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerSpaceShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;

/**
* A simple example showing how to create
* two datacenters with one host each and
* run cloudlets of two users with network
* topology on them.
*/
public class NetworkExample3 {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList1;
private static List<Cloudlet> cloudletList2;

/** The vmlist. */

private static List<Vm> vmlist1;
private static List<Vm> vmlist2;

/**
* Creates main() to run this example
*/
public static void main(String[] args) {

Log.printLine("Starting NetworkExample3...");
 try {
// First step: Initialize the CloudSim package. It
should be called
// before creating any entities.
int num_user = 2; // number of cloud users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events

// Initialize the CloudSim library

CloudSim.init(num_user, calendar, trace_flag);

// Second step: Create Datacenters

//Datacenters are the resource providers in CloudSim.
We need at list one of them to run a CloudSim simulation
Datacenter datacenter0 =
createDatacenter("Datacenter_0");
Datacenter datacenter1 =
createDatacenter("Datacenter_1");

//Third step: Create Brokers

DatacenterBroker broker1 = createBroker(1);
int brokerId1 = broker1.getId();

DatacenterBroker broker2 = createBroker(2);

int brokerId2 = broker2.getId();

//Fourth step: Create one virtual machine for each

broker/user
vmlist1 = new ArrayList<Vm>();
vmlist2 = new ArrayList<Vm>();

//VM description
int vmid = 0;
long size = 10000; //image size (MB)
int mips = 250;
int ram = 512; //vm memory (MB)
long bw = 1000;
int pesNumber = 1; //number of cpus
String vmm = "Xen"; //VMM name

//create two VMs: the first one belongs to user1

Vm vm1 = new Vm(vmid, brokerId1, mips, pesNumber, ram,
bw, size, vmm, new CloudletSchedulerTimeShared());

//the second VM: this one belongs to user2

Vm vm2 = new Vm(vmid, brokerId2, mips, pesNumber, ram,
bw, size, vmm, new CloudletSchedulerTimeShared());

//add the VMs to the vmlists

vmlist1.add(vm1);
vmlist2.add(vm2);

//submit vm list to the broker

broker1.submitVmList(vmlist1);
 broker2.submitVmList(vmlist2);

//Fifth step: Create two Cloudlets

cloudletList1 = new ArrayList<Cloudlet>();
cloudletList2 = new ArrayList<Cloudlet>();

//Cloudlet properties
int id = 0;
long length = 40000;
long fileSize = 300;
long outputSize = 300;
UtilizationModel utilizationModel = new
UtilizationModelFull();

Cloudlet cloudlet1 = new Cloudlet(id, length,

pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet1.setUserId(brokerId1);

Cloudlet cloudlet2 = new Cloudlet(id, length,

pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet2.setUserId(brokerId2);

//add the cloudlets to the lists: each cloudlet

belongs to one user
cloudletList1.add(cloudlet1);
cloudletList2.add(cloudlet2);

//submit cloudlet list to the brokers

broker1.submitCloudletList(cloudletList1);
broker2.submitCloudletList(cloudletList2);

//Sixth step: configure network

//load the network topology file

NetworkTopology.buildNetworkTopology("topology.brite");

//maps CloudSim entities to BRITE entities

//Datacenter0 will correspond to BRITE node 0
int briteNode=0;

NetworkTopology.mapNode(datacenter0.getId(),briteNode);

//Datacenter1 will correspond to BRITE node 2

briteNode=2;

NetworkTopology.mapNode(datacenter1.getId(),briteNode);

//Broker1 will correspond to BRITE node 3

briteNode=3;
NetworkTopology.mapNode(broker1.getId(),briteNode);

//Broker2 will correspond to BRITE node 4

 briteNode=4;
NetworkTopology.mapNode(broker2.getId(),briteNode);

// Sixth step: Starts the simulation

CloudSim.startSimulation();

// Final step: Print results when simulation is over

List<Cloudlet> newList1 =
broker1.getCloudletReceivedList();
List<Cloudlet> newList2 =
broker2.getCloudletReceivedList();

CloudSim.stopSimulation();

Log.print("=============> User "+brokerId1+" ");

printCloudletList(newList1);

Log.print("=============> User "+brokerId2+" ");

printCloudletList(newList2);

Log.printLine("NetworkExample3 finished!");
}
catch (Exception e) {
e.printStackTrace();
Log.printLine("The simulation has been terminated due
to an unexpected error");
}
}

private static Datacenter createDatacenter(String name){

// Here are the steps needed to create a PowerDatacenter:

// 1. We need to create a list to store
// our machine
List<Host> hostList = new ArrayList<Host>();

// 2. A Machine contains one or more PEs or CPUs/Cores.

// In this example, it will have only one core.
List<Pe> peList = new ArrayList<Pe>();

int mips = 1000;

// 3. Create PEs and add these into a list.

peList.add(new Pe(0, new PeProvisionerSimple(mips))); //
need to store Pe id and MIPS Rating

//4. Create Host with its id and list of PEs and add them to
the list of machines
int hostId=0;
int ram = 2048; //host memory (MB)
long storage = 1000000; //host storage
int bw = 10000;
 //in this example, the VMAllocatonPolicy in use is
SpaceShared. It means that only one VM
//is allowed to run on each Pe. As each Host has only one
Pe, only one VM can run on each Host.
hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList,
new VmSchedulerSpaceShared(peList)
)
); // This is our machine

// 5. Create a DatacenterCharacteristics object that stores

the
// properties of a data center: architecture, OS, list of
// Machines, allocation policy: time- or space-shared,
time zone
// and its price (G$/Pe time unit).
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource
located
double cost = 3.0; // the cost of using
processing in this resource
double costPerMem = 0.05; // the cost of using memory
in this resource
double costPerStorage = 0.001; // the cost of using
storage in this resource
double costPerBw = 0.0; // the cost of using
bw in this resource
LinkedList<Storage> storageList = new LinkedList<Storage>();
//we are not adding SAN devices by now

DatacenterCharacteristics characteristics = new

DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost,
costPerMem,
costPerStorage, costPerBw);

// 6. Finally, we need to create a PowerDatacenter object.

Datacenter datacenter = null;
try {
datacenter = new Datacenter(name, characteristics, new
VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}
 //We strongly encourage users to develop their own broker
policies, to submit vms and cloudlets according
//to the specific rules of the simulated scenario
private static DatacenterBroker createBroker(int id){

DatacenterBroker broker = null;

try {
broker = new DatacenterBroker("Broker"+id);
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}

/**
* Prints the Cloudlet objects
* @param list list of Cloudlets
*/
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent +
"Data center ID" + indent + "VM ID" + indent +
"Time" + indent + "Start Time" + indent + "Finish Time");

for (int i = 0; i < size; i++) {

cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() + indent +
indent);

if (cloudlet.getCloudletStatus() == Cloudlet.SUCCESS){
Log.print("SUCCESS");

DecimalFormat dft = new DecimalFormat("###.##");

Log.printLine( indent + indent +
cloudlet.getResourceId() + indent + indent + indent +
cloudlet.getVmId() +
indent + indent +
dft.format(cloudlet.getActualCPUTime()) + indent + indent +
dft.format(cloudlet.getExecStartTime())+
indent + indent +
dft.format(cloudlet.getFinishTime()));
}
}

}
}
 4. Create a simulation showing how to create a datacenter with one host and a network topology and
and run one cloudlet on it. Here, instead of using a BRIE file describing the links, links are
inserted in the code.

package org.cloudbus.cloudsim.examples.network;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.List;

import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;
import org.cloudbus.cloudsim.Datacenter;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.NetworkTopology;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;
import org.cloudbus.cloudsim.UtilizationModel;
import org.cloudbus.cloudsim.UtilizationModelFull;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.VmAllocationPolicySimple;
import org.cloudbus.cloudsim.VmSchedulerTimeShared;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;

/**
* A simple example showing how to create
* a datacenter with one host and a network
* topology and and run one cloudlet on it.
* Here, instead of using a BRIE file describing
* the links, links are inserted in the code.
*/
public class NetworkExample4 {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList;

/** The vmlist. */

private static List<Vm> vmlist;

/**
* Creates main() to run this example
*/
public static void main(String[] args) {
 Log.printLine("Starting NetworkExample4...");

try {
// First step: Initialize the CloudSim package. It
should be called
// before creating any entities.
int num_user = 1; // number of cloud users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events

// Initialize the CloudSim library

CloudSim.init(num_user, calendar, trace_flag);

// Second step: Create Datacenters

//Datacenters are the resource providers in CloudSim.
We need at list one of them to run a CloudSim simulation
Datacenter datacenter0 =
createDatacenter("Datacenter_0");

//Third step: Create Broker

DatacenterBroker broker = createBroker();
int brokerId = broker.getId();

//Fourth step: Create one virtual machine

vmlist = new ArrayList<Vm>();

//VM description
int vmid = 0;
int mips = 250;
long size = 10000; //image size (MB)
int ram = 512; //vm memory (MB)
long bw = 1000;
int pesNumber = 1; //number of cpus
String vmm = "Xen"; //VMM name

//create VM
Vm vm1 = new Vm(vmid, brokerId, mips, pesNumber, ram,
bw, size, vmm, new CloudletSchedulerTimeShared());

//add the VM to the vmList

vmlist.add(vm1);

//submit vm list to the broker

broker.submitVmList(vmlist);

//Fifth step: Create one Cloudlet

cloudletList = new ArrayList<Cloudlet>();

//Cloudlet properties
int id = 0;
long length = 40000;
long fileSize = 300;
long outputSize = 300;
 UtilizationModel utilizationModel = new
UtilizationModelFull();

Cloudlet cloudlet1 = new Cloudlet(id, length,

pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet1.setUserId(brokerId);

//add the cloudlet to the list

cloudletList.add(cloudlet1);

//submit cloudlet list to the broker

broker.submitCloudletList(cloudletList);

//Sixth step: configure network

//maps CloudSim entities to BRITE entities

NetworkTopology.addLink(datacenter0.getId(),broker.getId(),10.0,10);

// Seventh step: Starts the simulation

CloudSim.startSimulation();

// Final step: Print results when simulation is over

List<Cloudlet> newList =
broker.getCloudletReceivedList();

CloudSim.stopSimulation();

printCloudletList(newList);

Log.printLine("NetworkExample4 finished!");
}
catch (Exception e) {
e.printStackTrace();
Log.printLine("The simulation has been terminated due
to an unexpected error");
}
}

private static Datacenter createDatacenter(String name){

// Here are the steps needed to create a PowerDatacenter:

// 1. We need to create a list to store
// our machine
List<Host> hostList = new ArrayList<Host>();

// 2. A Machine contains one or more PEs or CPUs/Cores.

// In this example, it will have only one core.
List<Pe> peList = new ArrayList<Pe>();

int mips = 1000;

// 3. Create PEs and add these into a list.

 peList.add(new Pe(0, new PeProvisionerSimple(mips))); //
need to store Pe id and MIPS Rating

//4. Create Host with its id and list of PEs and add them to
the list of machines
int hostId=0;
int ram = 2048; //host memory (MB)
long storage = 1000000; //host storage
int bw = 10000;

hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList,
new VmSchedulerTimeShared(peList)
)
); // This is our machine

// 5. Create a DatacenterCharacteristics object that stores

the
// properties of a data center: architecture, OS, list of
// Machines, allocation policy: time- or space-shared,
time zone
// and its price (G$/Pe time unit).
String arch = "x86"; // system architecture
String os = "Linux"; // operating system
String vmm = "Xen";
double time_zone = 10.0; // time zone this resource
located
double cost = 3.0; // the cost of using
processing in this resource
double costPerMem = 0.05; // the cost of using memory
in this resource
double costPerStorage = 0.001; // the cost of using
storage in this resource
double costPerBw = 0.0; // the cost of using
bw in this resource
LinkedList<Storage> storageList = new LinkedList<Storage>();
//we are not adding SAN devices by now

DatacenterCharacteristics characteristics = new

DatacenterCharacteristics(
arch, os, vmm, hostList, time_zone, cost,
costPerMem,
costPerStorage, costPerBw);

// 6. Finally, we need to create a PowerDatacenter object.

Datacenter datacenter = null;
try {
datacenter = new Datacenter(name, characteristics, new
VmAllocationPolicySimple(hostList), storageList, 0);
 } catch (Exception e) {
e.printStackTrace();
}

return datacenter;
}

//We strongly encourage users to develop their own broker

policies, to submit vms and cloudlets according
//to the specific rules of the simulated scenario
private static DatacenterBroker createBroker(){

DatacenterBroker broker = null;

try {
broker = new DatacenterBroker("Broker");
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}

/**
* Prints the Cloudlet objects
* @param list list of Cloudlets
*/
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;

String indent = " ";

Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent +
"Data center ID" + indent + "VM ID" + indent +
"Time" + indent + "Start Time" + indent + "Finish Time");

for (int i = 0; i < size; i++) {

cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() + indent +
indent);

if (cloudlet.getCloudletStatus() == Cloudlet.SUCCESS){
Log.print("SUCCESS");

DecimalFormat dft = new DecimalFormat("###.##");

Log.printLine( indent + indent +
cloudlet.getResourceId() + indent + indent + indent +
cloudlet.getVmId() +
indent + indent +
dft.format(cloudlet.getActualCPUTime()) + indent + indent +
dft.format(cloudlet.getExecStartTime())+
indent + indent +
dft.format(cloudlet.getFinishTime()));
}
 }

}
}
Power Exercises

1. A simulation of a heterogeneous non-power aware data center: all hosts consume maximum
power all the time.

import java.io.IOException;
import java.util.Calendar;
import java.util.List;
import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.DatacenterBroker;
import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Vm;
import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.examples.power.Constants;
import org.cloudbus.cloudsim.examples.power.Helper;
import org.cloudbus.cloudsim.power.PowerDatacenterNonPowerAware;
import org.cloudbus.cloudsim.power.PowerHost;
import org.cloudbus.cloudsim.power.PowerVmAllocationPolicySimple;
public class NonPowerAware {
        /**
         * Creates main() to run this example.
         *
         * @param args the args
         * @throws IOException
         */
        public static void main(String[] args) throws IOException {
                String experimentName = "random_npa";
                String outputFolder = "output";
                Log.setDisabled(!Constants.ENABLE_OUTPUT);
                Log.printLine("Starting " + experimentName);
                try {
                        CloudSim.init(1, Calendar.getInstance(), false);
                        DatacenterBroker broker = Helper.createBroker();
                        int brokerId = broker.getId();
                        List<Cloudlet> cloudletList = RandomHelper.createCloudletList(
                                        brokerId,
                                        RandomConstants.NUMBER_OF_VMS);
                        List<Vm> vmList = Helper.createVmList(brokerId, cloudletList.size());
                        List<PowerHost> hostList =
Helper.createHostList(RandomConstants.NUMBER_OF_HOSTS);
                        PowerDatacenterNonPowerAware datacenter = (PowerDatacenterNonPowerAware)
Helper.createDatacenter(
                                        "Datacenter",
                                        PowerDatacenterNonPowerAware.class,
                                        hostList,
                                        new PowerVmAllocationPolicySimple(hostList));
                        datacenter.setDisableMigrations(true);
                        broker.submitVmList(vmList);
                        broker.submitCloudletList(cloudletList);
                        CloudSim.terminateSimulation(Constants.SIMULATION_LIMIT);
                        double lastClock = CloudSim.startSimulation();
                        List<Cloudlet> newList = broker.getCloudletReceivedList();
                        Log.printLine("Received " + newList.size() + " cloudlets");
                        CloudSim.stopSimulation();
                        Helper.printResults(
                                        datacenter,
                                        vmList,
                                        lastClock,
                                        experimentName,
                                        Constants.OUTPUT_CSV,
                                        outputFolder);
                } catch (Exception e) {
                        e.printStackTrace();
                        Log.printLine("The simulation has been terminated due to an unexpected error");
                        System.exit(0);
        }
                Log.printLine("Finished " + experimentName);
    }
}
 2. A simulation of a heterogeneous power aware data center that only applied DVFS, but no
dynamic optimization of the VM allocation. The adjustment of the hosts' power consumption
according to their CPU utilization is happening in the PowerDatacenter class.

package org.cloudbus.cloudsim.examples.power.random;
import java.io.IOException;
 */
public class Dvfs {
        /**
         * The main method.
         *
         * @param args the arguments
         * @throws IOException Signals that an I/O exception has
occurred.
         */
        public static void main(String[] args) throws IOException {
                boolean enableOutput = true;
                boolean outputToFile = false;
                String inputFolder = "";
                String outputFolder = "";
                String workload = "random"; // Random workload
                String vmAllocationPolicy = "dvfs"; // DVFS policy
without VM migrations
                String vmSelectionPolicy = "";
                String parameter = "";
                new RandomRunner(
                                enableOutput,
                                outputToFile,
                                inputFolder,
                                outputFolder,
                                workload,
                                vmAllocationPolicy,
                                vmSelectionPolicy,
                                parameter);
        }
 3. A simulation of a heterogeneous power aware data center that applies the Static Threshold (THR)
VM allocation policy and Random Selection (RS) VM selection policy.

package org.cloudbus.cloudsim.examples.power.random;
import java.io.IOException;
public class ThrRs {
        /**
         * The main method.
         *
         * @param args the arguments
         * @throws IOException Signals that an I/O exception has occurred.
         */
        public static void main(String[] args) throws IOException {
                boolean enableOutput = true;
                boolean outputToFile = false;
                String inputFolder = "";
                String outputFolder = "";
                String workload = "random"; // Random workload
                String vmAllocationPolicy = "thr"; // Static Threshold (THR) VM allocation
policy
                String vmSelectionPolicy = "rs"; // Random Selection (RS) VM selection policy
                String parameter = "0.8"; // the static utilization threshold
                new RandomRunner(
                                enableOutput,
                                outputToFile,
                                inputFolder,
                                outputFolder,
                                workload,
                                vmAllocationPolicy,
                                vmSelectionPolicy,
                                parameter);
    }
}