Abstract. Numerous studies have been targeting the problem of scheduling
divisible workloads in Cloud computing environments. The UMR (Uniform
Multi-Round) algorithm stands out from all others by being the first closeform optimal scheduling algorithm. However, present algorithms, including
the UMR, do not pay due attention to optimizing the set of workers that
get selected to participate in processing workload chunks. In addition to
the absence of a good resource selection policy, the UMR relies primarily
in its computation on the CPU speed and overlooks the role of other key
parameters such as network bandwidth. In this paper, we propose an extended version of UMR, called UMR2, that overcomes these limitations and
adopts a worker selection policy that aims at minimizing the makespan.
We, theoretically and experimentally, show that UMR2 is superior to UMR,
specifically in a WAN computing platform such as the Cloud environments.

14 trang |

Chia sẻ: thanhle95 | Lượt xem: 44 | Lượt tải: 0
Bạn đang xem nội dung tài liệu **Resources management algorithm for the cloud environment**, để tải tài liệu về máy bạn click vào nút DOWNLOAD ở trên

JOURNAL OF SCIENCE OF HNUE
Natural Sci., 2011, Vol. 56, No. 7, pp. 44-57
RESOURCES MANAGEMENT ALGORITHM
FOR THE CLOUD ENVIRONMENT
Phan Thanh Toan, Nguyen The Loc(∗)
Hanoi University of Education
(∗)E-mail: locnt@hnue.edu.vn
Abstract. Numerous studies have been targeting the problem of scheduling
divisible workloads in Cloud computing environments. The UMR (Uniform
Multi-Round) algorithm stands out from all others by being the first close-
form optimal scheduling algorithm. However, present algorithms, including
the UMR, do not pay due attention to optimizing the set of workers that
get selected to participate in processing workload chunks. In addition to
the absence of a good resource selection policy, the UMR relies primarily
in its computation on the CPU speed and overlooks the role of other key
parameters such as network bandwidth. In this paper, we propose an ex-
tended version of UMR, called UMR2, that overcomes these limitations and
adopts a worker selection policy that aims at minimizing the makespan.
We, theoretically and experimentally, show that UMR2 is superior to UMR,
specifically in a WAN computing platform such as the Cloud environments.
Keywords: Divisible loads, multi-round algorithms, cloud computing.
1. Introduction
By definition, a divisible load is a load that can be partitioned into any arbi-
trary number of load fractions [1]. This kind of workload arises in many domains
of science such as protein sequence analysis, simulation of cellular micro physiology,
and more [2, 3]. Per the divisible load theory [1], the scheduling problem is identified
as Given an arbitrary divisible workload, in what proportion should the workload
be partitioned and distributed among the workers so that the entire workload is
processed in the shortest possible time. Any scheduling algorithm should address
the following issues:
Workload partitioning problem: This problem is concerned with the method
by which the algorithm should divide the workload in order to dispatch to workers.
Resource selection problem: This problem is concerned with how to select the
best set of workers that can process the workload partitions such that the makespan
is minimal.
First multi-round algorithmMI (Multiple Iteration), introduced by Bharadwaj
[1], utilizes the overlapping between communication and computation processes at
44
Resources management algorithm for the cloud environment
workers. In MI algorithm the number of rounds is fixed and predefined. It overlooks
communication and computation latencies. Beaumont [4] proposed a multi-round
scheduling algorithm that fixes the execution time for each round. This enabled the
author to give analytical proof of the algorithm’s asymptotic optimality. Yang et al.
[2], through their UMR algorithm, designed a better algorithm that extends the MI
by considering latencies. However, in UMR, the size of workload chunks delivered
to workers is solely calculated based on workers CPU power; the other key system
parameters, such as network bandwidth, are not factored in.
One apparent shortcoming in many scheduling algorithms [1, 2, 4] is the aban-
don of designing a solid selection policy for generating the best subset of available
workers. Part of the reason is that the main focus of these algorithms is confined
to the LAN environment, which makes them not perfectly suitable for a WAN en-
vironment such as the Cloud environments [3]. In the Cloud, resource computing
(workers) join and leave the computing platform dynamically. In the Cloud environ-
ments, we cannot assume that all available resources, which may be in thousands,
must participate in the scheduling process. Therefore, the above mentioned algo-
rithm might not be appropriate for the Cloud. The more recent algorithms discussed
in [2] very tersely allude to this problem by proposing primitive intuitive solutions
that are not back up by any analytical model.
In this paper, we propose a new scheduling algorithm, UMR2 (inspired by
UMR [2]), which is better and more realistic. UMR2 is superior to UMR with
respect to two aspects. First, unlike UMR that relies primarily in its computation
on the CPU speed, UMR2 factors in several other parameters, such as bandwidth
and all types of latencies which renders the UMR2 a more realistic model. Second,
UMR2 is equipped with a worker selection policy that finds out the best workers.
As a result, our experiments show that our UMR2 algorithm outperforms previously
proposed algorithm including the UMR.
2. Content
2.1. The heterogeneous computing platform
Let us consider a computation Cloud in which a master process has access to
N worker processes and each process runs in a particular computer. The master can
divide the total load Ltotal into arbitrary chunks and delivers them to appropriate
workers. The following notation will be used throughout this paper:
Wi: worker number i.
N : total number of available workers.
n: number of workers that are actually selected.
m: the number of rounds.
chunkji : the fraction of total workload that the master delivers toWi in round
j (i = 1,..,n ;j = 1,..,m).
45
Phan Thanh Toan and Nguyen The Loc
Si: computation speed of the worker i (flop/s).
Bi: the data transfer rate of the connection link between the master and Wi
(flop/s).
Tcompji: computation time required for Wi to process chunkji.
cLati : the fixed overhead time (second) needed by Wi to start computation.
nLati : the overhead time (second) incurred by the master to initiate a data
transfer to Wi. We denote total latencies by Lati = cLati + nLati.
Tcommji: communication time required for master to send chunkji to Wi.
Tcommji = nLati + chunkji/Bi ;
Tcompji = cLati + chunkji/Si ;
roundj: the workload dispatched during round j.
Roundj = chunkj1 + chunkj2 + ...+ chunkjn.
2.2. Overview of the UMR algorithm
2.2.1. Load partitioning policy
UMR adopts a load partition policy that ensures that each worker spends the
equal CPU time like others through a round; network bandwidth is not taken into
account: cLati + chunkji/Si = constj , so we derive
chunkji =
Si
n∑
k=1
Sk
roundj + βi (2.1)
where
βi =
Si
n∑
k=1
Sk
n∑
k=1
(SkcLatk)− SicLati (2.2)
2.2.2. Induction relation on chunk sizes
To fully utilize the network bandwidth, the dispatching of the master and the
computation of Wn should finish at the same time
roundj = φ
j(round0 − η) + η (2.3)
where
46
Resources management algorithm for the cloud environment
φ =
(
n∑
i=1
Si
Bi
)−1
(2.4)
η =
n∑
i=1
(Si × cLati)−
n∑
i=1
Si ×
n∑
i=1
(
βi
Bi
+ nLati
)
n∑
i=1
Si
Bi
− 1
(2.5)
2.2.3. Determining the first round parameters
Since the objective of the UMR is to minimize the makespan of the application,
we can write:
F (m, round0) =
n∑
i=1
(
chunk0i
Bi
+ nLati
)
+
m−1∑
j=0
(
chunkjn
Sn
+ cLatn
)
(2.6)
At the same time, we also have the constraint that the chunk sizes sum up to
the total workload:
G (m, round0) = mη + (round0 − η) 1− φ
m
1− φ − Ltotal = 0
This optimization problem can be solved by the Lagrangian method [2, 5].
2.2.4. Worker selection policy
UMR sorts workers according to Si/Bi in increasing order, and selects the first
n workers out of the original N workers such that: S1/B1 + S2/B2 + + Sn/Bn < 1
Furthermore, UMR requires that, the computation-communication ratio Bi/Si
be larger than the number of workers n:
Bi/Si > n(∀i = 1, 2, ..., N) (2.7)
2.3. The new UMR2 algorithm
2.3.1. Load partitioning policy
Unlike the UMR, which considers the CPU power only, our algorithm considers
both of the CPU power and the network bandwidth when partitioning the load:
cLati + chunkji/Si + nLati + chunkji/Bi = constj
We set: Ai = BiSi/(Bi + Si)
47
Phan Thanh Toan and Nguyen The Loc
so we have
chunkji = αiroundj + βi (2.8)
where αi = Ai/(A1 + A2 + ... + An)
βi = αi[A1(Lat1 − Lati) + ... + An(LatnLati)] (2.9)
Expressions (2.8) and (2.9) show the equal role that CPU power (Si) and band-
width (Bi) play. This renders the UMR2 a more realistic algorithm and therefore,
a better one with respect to performance.
2.3.2. Induction relation on chunk sizes
Similar to the induction relation derived in Section 2.2.2 for the UMR, we
have:
roundj = θ
j(round0 − η) + η (2.10)
where
θ = Bn/(Bn + Sn)/[S1/(B1 + S1) + ... + Sn/(Bn + Sn)] (2.11)
η =
(
βn + cLatn −
n∑
i=1
(
nLati +
βi
Bi
))/(
n∑
i=1
αi
Bi
− αn
Sn
)
2.3.3. Determining the first round parameters
To find out round0 and m of UMR2, we minimize the makespanUMR2 :
F (m, round0) =
n∑
i=1
(
chunk0i
Bi
+ nLati
)
+
m−1∑
j=0
(
chunkjn
Sn
+ cLatn
)
(2.12)
subject to: G(m, round0) = mη + (round0 − η)(1− θm)/(1− θ)− Ltotal = 0
After obtaining m and round0 by using Lagrangian method, we can obtain
the value of roundj and chunkji using (2.10) and (2.8), respectively.
2.3.4. Worker selection policy
Let V denote the original set of N available workers (|V | = N). In this
subsection we explain our resource selection policy that aims at finding the best
subset V ∗(V ∗ ⊆ V, |V ∗| = n) that minimizes the makespan.
Algorithm 1: Resource Selection(V)
Begin
Search Wn ∈ V such that:
Bn/(Bn + Sn) ≤ Bi/(Bi + Si)∀Wi ∈ V
48
Resources management algorithm for the cloud environment
V ∗1 = Branch and Bound(V );
V ∗2 = Greedy(V , θ < 1); V
∗
3 = Greedy(V , θ = 1);
select V ∗ ∈ {V ∗1 , V ∗2 , V ∗3 } such that
m(V ∗) = min{m1(V ∗1 ), m2(V ∗2 ), m3(V ∗3 )} ;
return (V ∗);
End
If Wi denotes worker i, then Wn denotes the last worker that receives load
chunks in a round, and W1 denotes the first worker that receives chunks in a round.
Our selection, as sketched in Algorithm 1, starts with finding the last worker (Wn)
that should receive chunks in a round. Therefore, V ∗ is initialized by {Wn}. After-
wards, the selection algorithm, depending on θ, examines three cases using different
search algorithms aiming at finding the best algorithm that adds more workers to
V ∗. After obtaining the three candidate V ∗ sets, the algorithm chooses the one that
produces the minimum makespan. When θ =1, and by using (2.12), we compute
the makespan as follows:
makespanUMR2 =
Ltotal∑
i∈V ∗
Ai
(
1
m
∑
i∈V ∗
Si
Bi + Si
+
Bn
Bn + Sn
)
+ C (2.13)
where C is a constant C =
∑
i∈V ∗
nLati +m.cLatn
Now, since
lim
m→∝
1− θ
1− θm =
{
0
1− θ
ifθ > 1
ifθ < 1
,
and since m (the number of rounds) is usually large (in our experiments, m is in
hundreds), we can write:
1− θ
1− θm ≈
{
0
1− θ
ifθ > 1
ifθ < 1
We evaluate the accuracy of this approximation by experiments mentioned in
Subsection 2.5.1
When θ > 1 and by substituting this term into (2.12) we get
makespanUMR2 =
Ltotal ×Bn
(Bn + Sn)
∑
i∈V ∗
BiSi
Bi + Si
+ C (2.14)
When θ < 1 and by substituting the above term into (2.12) we get
49
Phan Thanh Toan and Nguyen The Loc
makespanUMR2 = Ltotal
∑
i∈V ∗
Si
Bi + Si
/∑
i∈V ∗
BiSi
Bi + Si
+ C (2.15)
Based on the above analysis, we have three selection policies for generating
V ∗:
- Policy I (θ > 1): this policy aims at reducing the total idle time by pro-
gressively increasing the load processed in each round (i.e., roundj+1 > roundj∀j =
0, 1, ..., m− 1).
- Policy II (θ < 1): this policy aims at maximizing the number of workers
that can participate by progressively decreasing the load processed in each round
(i.e., roundj+1 < roundj∀j = 0, ..., m− 1).
- Policy III (θ = 1): this policy keeps the load processed in each round
constant (i.e., roundj+1 = roundj∀j = 0, 1, ..., m − 1). As shown in Algorithm 1,
three policies will be examined in order to choose the one that produces the minimum
makespan.
Next, we discuss each policy in more detail.
* Policy I (θ > 1)
From (2.14), we can see that under this policy, V ∗ is the subset that maximizes
the sum m1(V ∗) =
∑
i∈V ∗
BiSi
Bi + Si
subject to θ > 1 or
∑
i∈V ∗
Si
Bi + Si
<
Bn
Bn + Sn
(2.16)
One can observe that this is a Binary Knapsack [7] problem that can be solved
using the Branch-and-Bound algorithm [7].
* Policy II θ < 1)
From (2.15), we can see that under this policy, V ∗ is the subset that minimizes
m2(V ∗) =
∑
i∈V ∗
Si
Bi + Si
/∑
i∈V ∗
BiSi
Bi + Si
subject to θ < 1 or
∑
i∈V ∗
Si
Bi + Si
>
Bn
Bn + Sn
(2.17)
To start with, we should initiate V ∗ with the first worker, W0, that minimizes
m2().
Lemma 2.1. m2(V
∗) is minimum if V ∗ = {W0} such that B0 ≥ Bi∀Pi ∈ V .
50
Resources management algorithm for the cloud environment
Proof. Consider an arbitrary subset X ⊆ V,X = {P1, P2, ...Pr}. We have:
B0 > Bi ⇒ B0
r∑
i=1
Si
Bi + Si
>
r∑
i=1
BiSi
Bi + Si
S0
B0 + S0
B0S0
B0 + S0
<
r∑
i=1
Si
Bi + Si
r∑
i=1
BiSi
Bi + Si
⇒ m2(V ∗) < m2(X)
After adding W0 to V
∗, we should keep conservatively adding more workers
until constraint (2.17) is satisfied. In fact, the next Wk that should be added to V
∗
is the one that satisfies the following inequality:
m2(V
∗ ∪ {Wk}) ≤ m2(V ∗ ∪ {Wj})∀Wj ∈ V − V ∗
The Greedy algorithm described below progressively adds more Pk until V
∗
satisfies (2.17), i.e. until (θ < 1). The run time of this search is O(n).
Algorithm 2: Greedy(V, thetaCondition)
Begin
Search Wn ∈ V : Bn/(Bn + Sn) ≤ Bi/(Bi + Si)∀Wi ∈ V ;
Search W0 : B0 ≥ Bi(∀Wi ∈ V );V ∗ = {Wn,W0};V = V − V ∗;
Repeat
Search worker Wk satisfy
m2(V
∗ ∪ {Wk}) ≤ m2(V ∗ ∪ {Wj})∀Wj ∈ V
V ∗ = V ∗ ∪ {Wk};V = V − {Wk};
Until thetaCondition;
return (V ∗);
End
* Policy III θ = 1)
Under this policy, we need to find V ∗ that minimizes the following makespan
function
m3(V ∗) =
∑
i∈V ∗
Si
Bi + Si
/∑
i∈V ∗
BiSi
Bi + Si
subject to θ = 1 or
Bn
(Bn + Sn)
∑
i∈V ∗
Si
Bi + Si
= 1
51
Phan Thanh Toan and Nguyen The Loc
It is noticeable that m3() is the same as m2() (Policy II). However, the two
objective functions differ with respect to their constraints. Therefore, we can use
the same Greedy search algorithm explained earlier with the exception that the
termination condition should be θ = 1 (instead of θ < 1).
2.4. Analytical comparison between UMR2 and UMR
In this section we analytically show how UMR2 is always better than UMR
through the following lemmas.
Lemma 2.2. If the UMR2 and UMR algorithms end up with the same set of selected
workers (V ∗) then makespanUMR2 < makespanUMR
Proof. If we sort the n workers of V ∗ by Si/B + i in an increasing order:
S1/B1 < S2/B2 < < Sn/Bn < 1/n (2.18)
We can write
Bn/Sn > n→ Bn/(Bn + Sn) > n.Sn/(Bn + Sn) (2.19)
Concurrently, from (2.18) we derive
Sn/(Bn + Sn) > Si/(Bi + Si)(∀i = 1, 2, ..., n) (2.20)
From (2.19) and (2.20) we derive
Bn
Bn + Sn
>
n∑
i=1
Si
Bi + Si
⇒ θ > 1
In the case of θ > 1, makespanUMR2 is computed by (2.14)
makespanUMR2 =
Ltotal ×Bn
(Bn + Sn)
∑
i∈V ∗
BiSi
Bi + Si
+ C (2.21)
From (2.6) we derive:
makespanUMR =
Ltotal∑
i∈V ∗
Si
(
1 +
1− φ
φ− φm+1
)
+ C
From (2.18) we have
n∑
i=1
Si
Bi
1⇒ lim
m→∝
1− φ
φ− φm+1 = 0
52
Resources management algorithm for the cloud environment
and since m (the number of rounds) is usually large (in our experiments, m is in
hundreds), we can write: 1 + (1− φ)/(φ− φm+1) ≈ 1. So we have
makespanUMR =
(
Ltotal
/∑
i∈V ∗
Si
)
+ C (2.22)
From (2.18) we derive
⇒ Bn/(Bn + Sn) ≤ Bi/(Bi + Si)(∀i = 1, 2, ..., n)
⇒ Bn
Bn + Sn
n∑
i=1
Si ≤
n∑
i=1
BiSi
Bi + Si
⇒ Bn
/(
(Bn + Sn)
n∑
i=1
BiSi
Bi + Si
)
< 1
/
n∑
i=1
Si
And by considering (2.21) and (2.22) we derive:
⇒ makespanUMR2 < makespanUMR
Lemma 2.3. In all cases, makespanUMR2 < makespanUMR
Proof. If we denote:
A is the subset which chosen by UMR
B is the subset which chosen by UMR2
V 1, V 2, V 3 is the subsets which chosen by UMR2 in 3 cases: θ > 1, θ = 1,
θ < 1, respectively. Using Lemma 2, we have
makespanUMR(A) > makespanUMR2(A) (2.23)
As discussed in Policy I, V 1 is an optimal solution of the Knapsack system produced
by the Branch-and-bound algorithm. So we have
makespanUMR2(A) ≥ makespanUMR2(V 1) (2.24)
Because B is chosen by UMR2 by comparing V 1, V 2, V 3 so we have
makespanUMR2(V 1) ≥ makespanUMR2(B) (2.25)
From (2.23) (2.24) (2.25) we derive
makespanUMR(A) > makespanUMR2(B)
53
Phan Thanh Toan and Nguyen The Loc
2.5. Experimental results
In order to evaluate UMR2 experimentally, we developed a simulator using the
SIMGRID toolkit [6] which has been used to evaluate the original UMR algorithm.
To evaluate the UMR2 algorithm, we used the same metrics (Table 4) and the
same values of configuration parameters (Table 1) that were used to evaluate UMR.
We conducted a number of experiments that aim at showing the validity of our
approximation assumptions discussed in Section 2.3 and showing that the UMR2
algorithm is superior to its predecessor multi-round algorithms, namely LP and
UMR.
2.5.1. Validity of approximation assumptions
Table 1. Experiment parameters
Parameter Value
Number of workers N = 50
Total workload (flop) 106
Computation speed
(flop/s)
Randomly selected from
[Smin, 1.5× Smin], where Smin = 50
Communication rate
(flop/s)
Randomly selected from
[0.5×N × S −min, 1.5×N × Smin]
The experiments we conducted show that the absolute deviation between theo-
retically computed makespan, as analyzed in Section 2.3 and the makespan observed
through the simulation experiments is negligible as shown in Table 2.
Table 2. The absolute deviation
between the experiments and theories
nLat, cLat
(s)
D1 (%) D2 (%) D3 (%)
1 3.15 2.42 3.34
10−1 2.23 1.75 2.27
10−2 1.51 0.92 1.94
10−3 0.82 0.51 1.25
This confirms that the approximation assumptions adopted in our analysis are
plausible. Table 1 outlines the parameters that we used in our experiments.
Let us denote:
MKe is the makespan obtained from the experiments.
MK1, MK2, MK3 are the makespans computed by formula (2.13), (2.14) and
(2.15) respectively.
Di(i = 1, 2, 3) is the absolute deviation between the theoretical makespan
54
Resources management algorithm for the cloud environment
MKi and the experimental makespan MKe. Therefore:
Di = 100.
|MKi −MKe|
MKe
(%) i = 1, 2, 3
Table 2 summarizes the absolute deviations computed for different latencies.
From these results we can make the following remarks:
- The absolute deviation between the theoretical and the experimental makespan
ranges from 0.5% to 3.1%, which is negligible.
- We notice that D2 < D1 < D3. The justification is that the absolute
deviation (D) is proportional to the number of participating workers in a given
selection policy. The more workers participate, the larger D becomes. As we recall
that D2 represents the deviation caused by policy II (θ > 1), which is the most
conservative policy with respect to the number of workers allowed to participate.
D3 represents the deviation caused by policy III (θ < 1), which is the most relaxed
policy with respect to the number of participating workers. D1 of policy I (θ = 1)
falls in the middle with respect to the number of participating workers and according
the observed deviation.
2.5.2. Comparison with other algorithms
We compare UMR2 with the most powerful scheduling algorithm, namely
UMR [2, 8] and LP [4]. Table 3 outlines the configuration parameters used in the
simulation experiments. The performances of these algorithms have been compared
with respect to three metrics:
The normalized makespan, that is normalized to the run time achieved by the
best algorithm in a given experiment;
The rank which ranges from 0 (best) to 2 (worst);
The degradation from the best, which measures the relative difference, as a
percentage, between the makespan achieved by a given algorithm and the makespan
achieved by the best one.
Table 3. Simulation parameters
Parameters Values
N : Number of workers 10, 12,.., 50