Simulating Cloud Deployment Options for Software Migration Support

Cloud computing is emerging as a promising new paradigm that aims at delivering computing resources and services on demand. To cope with the frequently found over- and under-provisioning of resources in conventional data centers, cloud computing technologies enable to rapidly scale up and down according to varying workload patterns. However, most software systems are not built for utilizing this so called elasticity and therefore must be adapted during the migration process into the cloud. Here, the selection of a specific cloud provider is the most obvious and basic cloud deployment option. Furthermore, the mapping between services and virtual machine instances must be considered when migrating to the cloud and the specific adaptation strategies, like allocating a new virtual machine instance if the CPU utilization is above a given threshold, have to be chosen and configured. The set of combinations of the given choices form a huge design space which is infeasible to test manually. The simulation of a cloud deployment option can assist in solving this problem. A simulation is often faster than executing real world experiments. Furthermore, the adaptation to the software system that shall be migrated requires less effort at a modeling layer. The simulation can be utilized by an automatic optimization algorithm to find the best ratio between high performance and low costs. Our main objective in this study is the implementation of a software that enables the simulation of cloud deployment options on a language independent basis.

Textprobe:
Chapter 3, Simulation Input:
3.1, Overview:
The input parameters MIPIPS and instruction count are related to instructions. The MIPIPS serve as a measure for the performance of a CPU. The instruction count of a method serves as an indicator for the work that has to be conducted by the CPU if the method is called.
Instructions in general can be instructions on a low level machine language like Assembler, on an intermediate level like Java bytecode, or on the level of a high level language like Java. For this thesis, we define instructions as a well defined set of statements that lies between the intermediate level and the high level language definition. As instructions we define declarations of a variable, assignments with at least one operation on the right hand side like x = 3 + 2, comparisons, field accesses, and class creations.
Most of the time when we talk about instructions, we mean integer plus instructions. We define an integer plus instruction as the assignment to a variable and on the right hand side of the assignment two integer types are combined with a plus statement, e.g., x = y + 3 where y is an integer variable. For simplicity and shortness, we omit integer plus and simply write instructions, if the meaning is unambiguous.
3.2, MIPIPS:
This section describes what mega integer plus instructions per second (MIPIPS) are and why we need them. Furthermore, our benchmark for derivation of MIPIPS is explained.
3.2.1, Description:
CloudSim requires MIPS as a measure for the computing performance of virtual machine instances. However, we consider MIPS as too coarse grained. Most CPUs need different times for different low level instructions. For example, a division of two doubles typically takes longer than an addition of two integers on current CPUs. Furthermore, CloudSim does not suggest how to measure MIPS.
We introduce MIPIPS as the measure for describing the computing performance and express instructions like double plus as integer plus instructions through a conversion. Notably, we could have used, e.g., mega double plus instructions per second (MDPIPS) as the measure for computing performance and normalized all other instructions to double plus instructions. However, we wanted an underlying instruction type that is faster than most other instructions because the conversion factors become more readable. For example, if we would have used a class creation instruction, mostly all other instructions would be between 0 and 1, and saying that one integer plus can be performed in 0.0004 class creation instructions is improper.
We do not use already existing benchmarks like Dhrystone or Cloudstone because we need an easily adaptable to new programming languages benchmark and we later describe an approach for counting instructions that bases on static analysis which needs an association between statements and the measure for computing performance.
Our MIPIPS benchmark measures the computing performance of a single core. Hence, a computer with one core will have the same MIPIPS value as a computer with 64 cores, if the performance of the one core on the first computer equals the performance of one core on the second computer. This is motivated by the fact that a program which is single-threaded is not faster on a computer with 64 cores. Furthermore, if the program has, e.g., two threads for processing, the performance depends on the synchronization method used in the program. However, the core count is also considered in the simulation. CloudSim defines the value TotalMIPS which is calculated by multiplying the core count with the MIPS. In accordance to this definition, we define TotalMIPIPS as the product of the core count and the MIPIPS value.
3.2.2, Derivation:
The basic idea for deriving MIPIPS is a benchmark that measures the runtime of a defined amount of integer plus instructions.
The runtime of a single instruction cannot be measured accurately because measurement techniques like the usage