Cloud Computing Simulation Using CloudSim

Last Updated : 13 Jan, 2023





CloudSim is an open-source framework, which is used to simulate cloud computing

infrastructure and services. It is developed by the CLOUDS Lab organization and is
written entirely in Java. It is used for modeling and simulating a cloud computing
environment as a means for evaluating a hypothesis prior to software development in
order to reproduce tests and results.
For example, if you were to deploy an application or a website on the cloud and
wanted to test the services and load that your product can handle and also tune its
performance to overcome bottlenecks before risking deployment, then such
evaluations could be performed by simply coding a simulation of that environment
with the help of various flexible and scalable classes provided by the CloudSim
package, free of cost. To know more, refer to the article – What is CloudSim.
Step-by-Step Implementation
Step 1: Download Eclipse IDE for Java Developers. It is developed by the CLOUDS
Lab organization and is written entirely in Java so we would need a Java IDE to
simulate a cloud scenario using CloudSim.
Step 2: Download the CloudSim 3.0.3 zip file from GitHub and extract the folders
within a folder in our computer storage.
Step 3: Download Apache Commons Math 3.6.1 zip file. It is required as it provides a
faster, more accurate, portable alternative to the regular Math and StrictMath classes
for large-scale computation in java files.
Step 4: Open Eclipse IDE and create a new Java Project.

Step 5: The above-mentioned Java Project should be created with the location of the
previously downloaded and extracted CloudSim 3.0.3 folder.

Select name of the project as mentioned and extract CloudSim folder

 Selecting the CloudSim 3.0.3 folder

Step 6: The JAR file from the extracted Apache Commons Math 3.6.1 folder needs to
be added to the JAR files of CloudSim.

Jar files of Apache Commons Math extracted to the Jar files of CloudSim

Step 7: Now the CloudSim Environment has been setup in the Eclipse IDE.
 CloudSim Environment Has Been Setup

Now Creating Datacenters, Virtual Machines, And Cloudlets In The CloudSim

Environment And Checking Its Output
Step 1: We open CloudSimExample2.java from the library on the left and create a
data center first.

Creating a datacenter in CloudSimExample2.java

Step 2: The initial configuration of one of VM(Virtual machine) is done i.e

mips(million instructions), ram(size of RAM), bw(bandwidth), etc. Here we create 4
VMs which are initialized with different configuration and added to vmlist, which is
the array list created to store all the 4VMs.
 Configuring Virtual Machine

Step 3: We create 8 cloudlets that are initialized with different properties or

characteristics i.e id length, outputsize, and filesize.

Creating Cloudlets With Different Characteristics

Step 4: Now the VM-cloudlet binding is done using the broker.

 VM-Cloudlet Binding

Below is the code for the above implementation of steps:

Note: You have to run this Java program on your Eclipse IDE after extracting
CloudSim 3.0.3 and Apache Commons Math 3.6.1 zip file. Only then will the code run
properly.

Java

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 data center

// with one host and run eight cloudlets on it

public class CloudSimExample1 {

// The cloudlet list

private static List<Cloudlet> cloudletList;

// The vmlist

private static List<Vm> vmlist;

@SuppressWarnings("unused")

public static void main(String[] args)

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

try {

// First step: Initialize the CloudSim package.

// It should be called before creating any

// entities. number of cloud users

int num_user = 1;

// Calendar whose fields have been initialized

// with the current date and time.

Calendar calendar = Calendar.getInstance();

// trace events

boolean trace_flag = false;

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 four 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; // bandwidth

int pesNumber = 1; // number of cpus

String vmm = "Xen"; // VMM name

// create 4 VMs

Vm vm1

= new Vm(vmid, brokerId, mips, pesNumber,

ram, bw, size, vmm,

new CloudletSchedulerTimeShared());

vmid++;

Vm vm2 = new Vm(

vmid, brokerId, mips * 2, pesNumber,

ram - 256, bw, size * 2, vmm,

new CloudletSchedulerTimeShared());

vmid++;
Vm vm3 = new Vm(

vmid, brokerId, mips / 2, pesNumber,

ram + 256, bw, size * 3, vmm,

new CloudletSchedulerTimeShared());

vmid++;

Vm vm 4

= new Vm(vmid, brokerId, mips * 4,

pesNumber, ram, bw, size * 4, vmm,

new CloudletSchedulerTimeShared());

vmid++;

// add the VM to the vmList

vmlist.add(vm1);

vmlist.add(vm2);

vmlist.add(vm3);

vmlist.add(vm4);

// submit vm list to the broker

broker.submitVmList(vmlist);
// Fifth step: Create eight Cloudlets

cloudletList = new ArrayList<Cloudlet>();

// Cloudlet properties

int id = 0;

long length = 400000;

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 * 2, pesNumber, fileSize * 2,

outputSize / 3, utilizationModel,

utilizationModel, utilizationModel);

cloudlet2.setUserId(brokerId);

id++;

Cloudlet cloudlet3 = new Cloudlet(

id, length / 2, pesNumber, fileSize * 3,

outputSize * 3, utilizationModel,

utilizationModel, utilizationModel);

cloudlet3.setUserId(brokerId);

Cloudlet cloudlet4 = new Cloudlet(

id, length / 3, pesNumber, fileSize / 3,

outputSize / 2, utilizationModel,

utilizationModel, utilizationModel);

cloudlet4.setUserId(brokerId);

Cloudlet cloudlet5 = new Cloudlet(

id, length * 3, pesNumber, fileSize / 2,

outputSize / 4, utilizationModel,

utilizationModel, utilizationModel);

cloudlet5.setUserId(brokerId);
Cloudlet cloudlet6 = new Cloudlet(

id, length / 4, pesNumber, fileSize * 4,

outputSize * 4, utilizationModel,

utilizationModel, utilizationModel);

cloudlet6.setUserId(brokerId);

Cloudlet cloudlet7 = new Cloudlet(

id, length * 4, pesNumber, fileSize,

outputSize * 2, utilizationModel,

utilizationModel, utilizationModel);

cloudlet7.setUserId(brokerId);

Cloudlet cloudlet8 = new Cloudlet(

id, length, pesNumber, fileSize / 4,

outputSize / 3, utilizationModel,

utilizationModel, utilizationModel);

cloudlet8.setUserId(brokerId);

// add the cloudlet to the list

cloudletList.add(cloudlet1);

cloudletList.add(cloudlet2);

cloudletList.add(cloudlet3);
cloudletList.add(cloudlet4);

cloudletList.add(cloudlet5);

cloudletList.add(cloudlet6);

cloudletList.add(cloudlet7);

cloudletList.add(cloudlet8);

// 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());

broker.bindCloudletToVm(

Cloudlet3.getCloudletId(), vm3.getId());

broker.bindCloudletToVm(

Cloudlet4.getCloudletId(), vm4.getId());
broker.bindCloudletToVm(

Cloudlet5.getCloudletId(), vm1.getId());

broker.bindCloudletToVm(

Cloudlet6.getCloudletId(), vm2.getId());

broker.bindCloudletToVm(

Cloudlet7.getCloudletId(), vm3.getId());

broker.bindCloudletToVm(

Cloudlet8.getCloudletId(), vm4.getId());

// Sixth step: Starts the simulation

CloudSim.startSimulation();

CloudSim.stopSimulation();

// Final step: Print results when simulation is

// over

List<Cloudlet> newList

= broker.getCloudletReceivedList();

printCloudletList(newList);
 Log.printLine("CloudSimExample1 finished!");

catch (Exception e) {

e.printStackTrace();

Log.printLine("Unwanted errors happen");

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.

// need to store Pe id and MIPS Rating

peList.add(

new Pe(0, new PeProvisionerSimple(mips)));

// 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;

private static DatacenterBroker createBroker()

DatacenterBroker broker = null;

try {

broker = new DatacenterBroker("Broker");

catch (Exception e) {

e.printStackTrace();

return null;

}
 return broker;

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()));

Step 5: Output after running the program is shown. One can see all the VM and
cloudlets are created and their finish time(performance) is different as their VM and
cloudlet configurations were different.

If we change the VM-cloudlet binding, we will get different outputs.

Summer-time is here and so is the time to skill-up! More than 5,000 learners have
now completed their journey from basics of DSA to advanced level development
programs such as Full-Stack, Backend Development, Data Science.

And why go anywhere else when our DSA to Development: Coding Guide will help
you master all this in a few months! Apply now to our DSA to Development
Program and our counsellors will connect with you for further guidance & support.