Gestión de Cambio

Programmatically speaking, this section solely focuses on testing the Scheduling service presented in Section 7.2.2. More specifically, the experiment is performed by invoking the

scheduleJobsmethods of three services:ExactScheduler,HybridScheduler, and HeuristicScheduler. In order to compare the three approaches, we use the following two metrics: i) the time it takes to produce a scheduling plan, i.e. solving time, and ii) the cost of the returned scheduling plan, i.e. solution optimality.

Dependent and Independent Variables

In our experiment, there are two sets of variables. The first one is related to the input, i.e. cloud environment and problem, and are calledindependent variables. The independent variables used in our experiments are i) number of jobs, ii) number of tasks, iii) number of available instance types, and iv) the job deadline. In our experiment, we assume that the number of applications is equal to the number of jobs. The other set of variables is called

dependent variablesand consists of i) solving time, and ii) the cost of a scheduling plan. Any changes in the independent variables will affect the dependent variables.

Each independent variable is assigned a default value, which is used as a baseline. In each experiment, we change only one independent variable while keeping the remaining variables unchanged. As a result, we are able to not only compare the solving time and

Table 8.1 Summary of the Independent and Dependent Variable

Name Type Default Description

Number of Jobs Independent 5 The number of jobs

Number of Tasks Independent 100 The number of tasks per job

Number of Type Independent 4 The number of available instance types Deadlines Independent 600 The amount of time in which a job must

be fully executed

Solving Time Dependent N/A The time it takes to find a scheduling plan for a given problem

Total cost Dependent N/A The cost of a returned scheduling plan solution optimality between three approaches but also investigate the affect of the independent variables on them.

Table 8.1 summarises all the independent and dependent variables used in this section. It also shows the default values of the independent variables. In other words, when one independent variable is changed, the others are set to their default values.

Input Synthesiser

In order to evaluate and compare the scheduling approaches, we need to generate the input which consists of available instance types, application, jobs (and their tasks), and the task execution times between instance types and applications. Automatically generate instance types, applications, and jobs based on the set of given independent variables is simple, however, generating task execution times is more complicated.

We develop the task execution generator, which automatically generates task execution times of given application and instance types. The main idea is to calculate a task execution time between an application and an instance type based on the task execution time of the same application on the nearest cheaper instance type. The logic is presented by Algorithm 8.1 which generate the task execution time between an application an all instance types.

Algorithm 8.1Generate Task Execution Times

1: functionGENERATE_TASK_EXEC_TIMES(a,T)

2: SortT by their prices in ascending order 3: t0 first type inT

4: ea,t0 a random value 5: fori2{1...|T| 1}do

6: d random number between 0.1 and _ppti

ti 1 7: ea,ti d⇥(ea,ti 1⇥

p_{ti 1} p_ti )

First, the instance types are sorted based on their prices in ascending order (Line 8.1), which means the first type on the list, denoted ast0, has the cheapest price. The execution

time of an application on the cheapest type is assigned to a random positive value (Line 4). Then, the algorithm loops through the remaining instance type. For each type, its task execution time is calculated based on theperformance improvement factord whichrepresents the relationship between the task execution times and prices of two instance types t1andt2,

assuming pt1 <pt2, as follow: et2 et1 =d_⇥ pt1 pt2 (8.1) Hence, it is possible to calculate a task execution time oft2given a task execution time

oft1and their prices:

et₂=d⇥et₁⇥p_pt1 t2

(8.2) Based on Formula 8.2, it is possible to make the following remarks:

• Ifd =1, thenet2 =et1⇥ pt₁

pt₂, which means the decrease in task execution time is equal

to the increase in price. For example, if pt2 =2⇥pt1 thenet2=et1/2. In this case, it

makes almost no difference selecting two VMs oft1or one VM oft2.

• Ifd <1, thenet2 <et1⇥ pt₁

pt₂, which means the decrease in task execution time is greater

than the increase in price. For example, if pt2 =2⇥pt1 thenet2<et1/2. In this case,

selecting one VMs oft2is more cost effective than selecting two VMs oft1.

• Ifd >1, thenet₂ >et₁⇥p_pt_t1

2, which means the decrease in task execution time is less

than the increase in price. For example, if pt₂ =2⇥pt₁ thenet₂>et₁/2. In this case,

selecting two VMs oft1is more cost effective than selecting one VM oft2.

• Ifd= pt2

pt₁, thenet2=et1, which means a task execution time remains the same between

two instance types. For example, even ifpt₂=2⇥pt₁,et₂ andet₁ are identical. In this

case, selecting two VMs oft1is more cost effective than selecting one VM oft2.

In other words,d represents the performance/cost trade-off between two instance types. For each instance type,d takes a random value between 0.1 and _ppti

ti 1, i.e. the ratio between

its price and the previous type’s (Line 6). It is then used to calculate a task execution time of an instance type (Line 7).

Algorithm 8.1 is applied for each application. The final result is the task execution times between all given applications and all available instance types.