CloudSim Plus: A Modern Java 8 Framework for Modeling and Simulation of Cloud Computing Infrastructures and Services

CloudSim Plus API is the main module that contains the framework API. It is the only independent module that is required to build simulation scenarios. Since such a module is available at Maven Central, there is no need to manually download the framework source code to build simulations. This module can just be added as a maven dependency to one’s own project and he or she will be ready to start building simulation scenarios.

CloudSim Plus Examples provides the original CloudSim examples, with refactored, well organized and updated code to use the CloudSim Plus API. It also includes new examples for CloudSim Plus exclusive features.

CloudSim Plus Testbeds implements some simulation testbeds in a repeatable manner. It provides base classes that allow a researcher to collect valid scientific results, such as average values and standard deviations, considering a specific confidence interval. They serve as examples on how to create broader testbed experiments.

CloudSim Plus Benchmarks is used just internally to measure the overhead of some CloudSim Plus features.

CloudSim Plus has a new package organization, which ensures better separation of concerns and make it easier to understand the project structure and to locate some class to use, extend or simply to analyse its source code and/or documentation. Packages with a strong color contain exclusive CloudSim Plus classes and interfaces, while the lightly colored ones were introduced to improve organization but usually just contain classes and interfaces from CloudSim. The white packages already existed in CloudSim.

CloudSim Plus also introduces documentation for every package, quickly explaining the goals of containing classes and interfaces, as well as the main class inside the package. Such a documentation is an excellent start point for researchers to get an overview of the framework.

Creating a cloud simulation using CloudSim Plus requires one to write a Java program that models the simulation scenario. The simplified diagram below presents the main interfaces involved in creating such scenarios. For every presented interface, there is one or more implementing classes that have to be actually instantiated (methods, attributes and several implementing classes were omitted for simplification).

The process of building a simulation scenario is described below. The goal of this section is to provide an overview of how to build cloud simulations using CloudSim Plus. It is not going to present the implementing classes for every presented interface. A complete simulation example is presented in the last sub-section of this section. More details on how to use CloudSim Plus are available at the official website.

CloudSim class is the first one that needs to be instantiated to start building a cloud simulation. CloudSim Plus just requires it to be instantiated using the default no-arguments constructor to initialize the simulation. The remaining objects that need to be instantiated are described as follows.

CloudSim Plus allows on-demand creation of Vms and Cloudlets, without requiring creation of DatacenterBrokers at runtime. The DatacenterBroker class was refactored to enable submission of new Vms and Cloudlets during simulation execution, accordingly requesting the creation of such objects into the cloud infrastructure. It also enables delaying the creation of submitted Cloudlets and Vms, which may be used to control the time when the researcher wants these objects to be created. For instance, Vm creation can be delayed to avoid upfront allocation of resource that may not be required immediately.

Vm migration is a well-known mechanism to optimize allocation of physical resources, which can be applied for different goals, such as reduction of: costs, energy consumption and resource wastage by consolidating multiple Vms into the same Host; network traffic by placing inter-communication Vms as close as possible; SLA violations by ensuring that required resources will be available for hosted Vms; etc. It is a fundamental mechanism to provide the so called elasticity, which enables resources to be on-demand allocated or released.

However, Vm migration is an expensive operation that causes service downtime, introduces overhead and must be performed carefully. Sometimes Vm migrations can be avoided by simply scaling under or overloaded Vms. Appropriately, CloudSim Plus provides vertical and horizontal Vm scaling mechanisms.

These two different kinds of Vm scaling, additionally with Vm migration algorithms, can be used selectively by an Hypervisor to provide a very efficient Vm allocation policy mechanism to achieve intended goals. This mechanism can decide the time to perform Vm migration, vertical or horizontal Vm scale. Depending on specific conditions, one action can be favored over other ones or even different actions can be performed at a given time. CloudSim Plus Vm Scaling mechanisms are discussed below.

Production of scientifically valid simulation results depends on several factors, which include the accuracy of the simulator, experiments reproducibility and collection of statistic metrics over multiple simulation runs. Although CloudSim Plus provides a lightweight, fast and easy way to model and run cloud simulation experiments, depending on the experiment scale, it may take several minutes to run. This is specially true when the workload is created from real and large datacenter traces.

CloudSim Plus was re-designed to enable running multiple experiments in parallel, in a multi-core machine, to reduce simulation time. Such a feature was enabled by changing every simulation attribute that was being managed in a static way, inside the CloudSim class, to be managed by instances of such a class. The benefits of this approach are two-fold: to initialize the simulation, one has just to instantiate a CloudSim object, instead of calling a static method with redundant parameters; each CloudSim instance owns all the objects and state that belong to a specific simulation, allowing each simulation to run in an independent and isolated manner.

The real time reduction that can be achieved by running simulations in parallel is tightly dependent of the simulation scenario and its scale. If the simulation is CPU-bound and is comprised of several runs, then the parallelization might provide large time reduction. On the other hand, small scale simulations or I/O-bound ones are not expected to take advantage of this feature.

An example available here shows how it is simple to parallelize simulation experiments in CloudSim Plus, using the Java 8 Stream API. Consider there is: a class called ParallelSimulationsExample, which represents a simulation scenario and contains a method run() to build and start a simulation; and then a list of instances of such a scenario with different configurations. Running each scenario instance is as simple as calling the single line of code below:

Since CloudSim class was re-designed, it enables using the Parallel Streams feature of Java 8, which makes it straightforward to execute simulations in parallel, as presented above. The syntax ParallelSimulationsExample::run may look unfamiliar, but it is the new Java 8 Method Reference feature for Functional Programming. It enables passing functions as parameter to another function, instead of just values. A reference to the run() method from the ParallelSimulationsExample class is being passed to the forEach() method. Thus, that line is not calling the run() method. Rather, it will be called inside the forEach() method when required.

One of the features a cloud infrastructure must provide is the ability to monitor running services. Monitoring capabilities can be used in different ways by involved parties. The cloud provider can, for instance: collect resource utilization to charge customers in a pay-per-use basis; assess fulfillment of customer SLA; or optimize resource allocation to avoid under and over resource provisioning. Customers can, for instance, assess if the kind of resources he/she has contracted is appropriated to his/her demand and then take the required actions if they are not.

Despite cloud resources usage is charged in a pay-per-use basis, it is up to the customer to correctly configure the services he/she is using, to ensure an expected quality of service for his/her final users. Scaling mechanisms that provide the so called elasticity are normally enabled and configured by the customer. Otherwise, resources are not automatically scaled, for instance, to attend bursts. CloudSim Plus thus provides Listeners as a mechanism to monitor simulation in runtime, allowing collection of metrics, resource allocation decision making (such as Vm scaling) and granular simulation execution feedback. Since the final goal of a simulation is the collection of data to be processed, assessed and validated, Listeners enable researchers to collect such data at any time interval they need, and writing it in any desired portable format such as CSV, JSON, XML, YML or any other.

Despite CloudSim Plus is far easier to use and provides several new useful features, understanding and correctly implementing large scale simulation scenarios may be challenging. Listeners can be used by researchers to follow up simulation execution and to collect data for debug purposes. Listeners are a variation of the Observer Design Pattern and were implemented in CloudSim Plus using the Java 8 Functional Interfaces. These interfaces enable a researcher to use Lambda Expressions to define the code that will capture an event, without requiring an anonymous class for each event to be handled.

Listeners were designed to allow defining different handlers for the same event, also enabling the framework itself to use them internally, as a type-safe message-passing mechanism. More information about existing issues with the current mechanism can be found here. Such Listeners are currently being used to implement Integration Tests to assess the accuracy of the simulation framework. Examples using some Listeners can be found here. Some available listeners are presented below, grouped by the class they belong to.

CloudSim Plus was comprehensively re-engineered to create relationships among classes, enabling chained calls such as cloudlet.getVm().getHost().getDatacenter(). This way, it stores references to actual objects, instead of just integer IDs to represent these relationships, which does not conform to an object-oriented design. These relationships can be seen at the Class Diagram already presented.

The line of code shown above provides a direct way to know what Vm a Cloudlet is running or will run, what Host such a Vm is or was placed into, and finally what Datacenter such a Host is settled down. The Null Object Design Pattern was also implemented to avoid the so propagated NullPointerException when making such a chained call.

Considering the large scale of cloud infrastructures, finding an optimal solution for issues such as Vm Placement is impracticable, since this is a NP-hard problem. Alternatively, heuristic techniques can be used to find a sub-optimal and satisfactory solution in a reasonable time. Some well-know heuristic methods include Tabu Search, Simulated Annealing and Ant Colony Systems. These methods usually start with an initial random solution for a defined problem and iterative and randomly look for other solutions. A fitness value to be maximized for each solution is computed by an utility function, then the solution finding stops when a desired fitness or number of iterations is reached.

CloudSim Plus provides a set of classes and interfaces to enable a researcher to build such heuristics for solving problems like Vm placement and migration. The interfaces provide a contract, by defining method signatures to: implement a solution generation and solution cost function (the fitness function is just the inverse of the cost); implement a function to update the solution search state; specify the number of maximum iterations, the probability for accepting each random solution and the predicate that defines when the solution finding must stop. The package org.cloudsimplus.heuristics contains such classes and interfaces and also includes a Simulated annealing heuristic to perform the map between Cloudlets and Vms.

Implementations of the CloudletScheduler interface, as presented in the Section How CloudSim Plus Works, define the algorithm used by a Vm to schedule the execution of its Cloudlets. One of the criticisms against simulation experiments is differences between some behaviors of the actual system being simulated and the simulation itself, which may reduce the simulation accuracy. Process scheduling is one of the behaviors that was neglected in cloud computing simulations up to now. The scheduling algorithm impacts some application metrics such as wait time and task completion time. A bad scheduling may lead to processes waiting for long time periods to use the CPU or, when a process is assigned to a CPU, it is not given enough CPU time. That situation is called starvation and may cause SLA violations.

The Completely Fair Scheduler used in recent version of the Linux Kernel provides a very efficient policy to avoid the mentioned issues. As an actual scheduler, it considers assigned tasks priorities to define the time slice that each process is allowed to use the CPU. It also tries to be fair when allocating these time slices to avoid starvation of low priority processes. CloudSim Plus introduces a implementation of the Completely Fair Scheduler to increase the accuracy of processes execution in simulation environments.

The already existing CloudletSchedulerTimeShared class provides a simplistic implementation that does not take processes priority into account and, in fact, it does not perform a preemption process when there are more processes to execute than the number of available CPUs. As an example, consider there are 3 CPU cores and 12 processes to be executed. Such a scheduler will make all these processes to be executed simultaneously, each one using 25% of a CPU core capacity (3 cores / 12 processes), enabling 4 processes to run in each core.

Even in recent actual processors, the presented situation is not possible, since technologies such as Intel Hyper-Threading (HT) just enables up to 2 processes running at the same time on each CPU core. In a real scheduler, if there are, for instance, 2 Hyper-Threading CPU cores allocated to 4 processes that are not using the entire cores capacity, a fourth process cannot use this remaining capacity. That capacity is in fact wasted, forcing the process to wait one of the others to be preempted, to open room for it to use the CPU. Therefore, the simplistic CloudletSchedulerTimeShared may achieve better but inaccurate results. However, how CPU capacity is wasted by actual process schedulers can be assessed in CloudSim Plus.

Besides all the exclusive features that have been presented, CloudSim Plus has additional characteristics that make it a promising cloud simulation framework. Some of them include: