The Journal of Supercomputing

, Volume 71, Issue 5, pp 1642–1656 | Cite as

Energy-efficient dynamic clusters of servers

  • Dilawaer Duolikun
  • Tomoya Enokido
  • Ailixier Aikebaier
  • Makoto Takizawa
Article

Abstract

Electric power consumed by servers has to be reduced in order to realize green societies. We consider computation (CP) and storage (ST) types of application processes performed on servers in this paper, where CPU and storage drives are mainly used, respectively. In the storage- and computation-based power consumption model proposed by the authors, the power consumption rate of a server depends on what types of processes are performed but is independent of how may processes are performed on the server. In the storage- and computation-based processing model, the execution time of an ST process depends on the number of concurrent CP and ST processes but the execution time of a CP process depends on only CP processes and is independent of ST processes. In our previous studies, the energy-aware algorithm is discussed to select a server in a cluster of servers for each request so that the total power consumption of the servers can be reduced. However, a server consumes electric power even if the server is idle, i.e. no process is performed. In this paper, we discuss a dynamic energy-aware (DEA) cluster which includes only active servers where at least one process is performed. A server for each request is selected in a dynamic cluster so that the total power consumption of servers in the cluster can be reduced. We evaluate the DEA algorithm in terms of the total power consumption and average execution time and show the total power consumption can be reduced.

Keywords

Power consumption mode Dynamic cluster Energy-aware cluster Storage- and computation-based power consumption (SCBPC) model Storage- and computation-based processing (SCB) model 

1 Introduction

In information systems, a client issues a request to a server in a cluster of servers and then the request is performed as a process on the server. In order to realize ecosystems [1], it is significant to reduce the total electric power consumption of servers in addition to achieving the performance and reliability objectives like response time. By abstracting essential properties which dominate the power consumption of a server from the experimental results, power consumption models of a server to perform application processes are discussed at macro level [2, 3, 4, 5, 6]. We classify application processes into three types; computation (CP), communication (CM), and storage (ST) types. In CP processes such as scientific computation applications, CPU resources are mainly consumed on servers. Here, the simple and extended power consumption models [2, 4, 7, 8] are discussed. The power consumption rate of a server to perform CP processes is maximum if at least one process is performed and minimum if no process is performed. In CM processes like FTP (file transfer protocol) [9], data are mainly transmitted. The power consumption model [7] to perform CM processes is discussed. Here, the power consumption rate of a server is proportional to the total transmission rate. The power consumption model of a server to perform a general type of application process is also discussed [3]. We consider computation (CP) and storage (ST) types of application processes in this paper.

Files in storage drives like hard disk drive (HDD) are read and written in ST applications. In the storage- and computation-based power consumption (SCBPC) model [10, 11] of a server to perform ST and CP, a server consumes electric power at rate which depends on types of concurrent processes but is independent of the number of the processes. In the storage- and computation-based processing (SCBP) model [11], the execution time of each CP process depends on the number of concurrent CP processes but is independent of concurrent ST processes. On the other hand, the execution time of an ST process depends on the number of concurrent CP and ST processes. The energy-aware (EA) algorithm [11] to select a server in a set of possible storage servers for a request is discussed by taking advantage of the SCBPC and SBCP models. Here, a server which is expected to consume the minimum power to perform current processes and the current request is selected. In the EA algorithm, an idle server spends electric power even if no process is performed in a cluster. That is, electric power which is not used to perform processes is consumed at an idle server. In this paper, we discuss the dynamic energy-aware (EDA) algorithm for selecting a server to reduce the total power consumption of servers in a cluster through reducing the unused power consumption of idle servers. The membership of a cluster is dynamically changed so that only non-idle servers where at least one process is performed are included in the cluster. Each time a process request is issued, a new server is invited to a cluster if the cluster is overloaded. If the cluster is underloaded, some idle servers are excluded in the cluster. Then, a server for each request is selected in a dynamic cluster so that the expected power consumption of servers to perform processes can be reduced.

We evaluate the DEA selection algorithm in terms of total power consumption of server and the total execution time of processes compared with the round-robin (RR), random (R), and DEA algorithms. We show the DEA algorithm implies smaller amount of total power consumption than the RR, R, and EA algorithms. We also show the load of each server is balanced in the DEA algorithm.

In Sect. 2, we briefly present the SCBPC model and SCBP model of a server. In Sect. 3, we discuss the DEA algorithm to select a server. In Sect. 4, we evaluate the DEA algorithm.

2 Power consumption and processing models

2.1 Computation rate

Let \(S\) be a cluster of servers \(s_1, \ldots , s_n (n \ge 1)\) in a system. CP processes and ST processes mainly use CPU and storage drives of a server, respectively. Let \(CP_t(\tau )\) be a collection of processes being performed on a server \(s_t\) at time \(\tau \). \(CCP_t(\tau )\) and \(CST_t(\tau )\) indicate collections of CP and ST processes performed on the server \(s_t\) at time \(\tau \), respectively. Here, \(CCP_t(\tau ) \cap CST_t(\tau ) = \phi \) and \(CP_t(\tau ) = CCP_t(\tau ) \cup CST_t(\tau )\). Let \(N_t(\tau )\), \(NC_t(\tau )\), and \(NS_t(\tau )\) be the numbers \(|CP_t(\tau )|\), \(|CCP_t(\tau )|\), and \(|CST_t(\tau )|\) of processes, respectively. A server \(s_t\) where \(N_t(\tau ) = 0\) is referred to as idle at time \(\tau \).

The power consumption rate \(E_t(\tau )\) (W) of a server \(s_t\) is one of four rates \(minE_t\), \(ST_t\), \(C_t\), and \(STC_t\) at time \(\tau \) depending on what types of processes are concurrently performed as shown in Fig. 1. The server \(s_t\) consumes electric power at the minimum rate \(minE_t\), i.e. \(E_t(\tau ) = minE_t\) if no process is performed at time \(\tau \). The area (1) in Fig. 1 shows the power consumption rate \(ST_t\) at which only ST processes are performed. Next, the area (2) indicates the power consumption rate \(C_t\) at which only CP processes are performed. Lastly, the area (3) shows the power consumption rate \(STC_t\) at which both CP and ST processes are performed. \(minE_t < ST_t < C_t < STC_t\). Let \(c_t\) and \(d_t\) be \(C_t - minE_t\) and \(ST_t-minE_t\), respectively. Thus, the power consumption rate \(E_t(\tau )\) depends on types of processes concurrently performed on a server \(s_t\) at time \(\tau \) but is independent of the number of the processes [12]:
Fig. 1

Power consumption

The power consumption rate \(E_t(\tau )\) (W) of a server \(s_t\) at time \(\tau \) is thus given as follows [12] :
$$\begin{aligned} E_{t}(\tau ) = minE_t + \delta _t(\tau ) \cdot d_t + \gamma _t(\tau ) \cdot c_t. \end{aligned}$$
(2.1)
Here, the factors \(\delta _t(\tau )\) and \(\gamma _t(\tau )\) show whether at least one ST process exists or not and at least one \(CP\) process exists or not, respectively, on a server \(s_t\) at time \(\tau \). \(\delta _t(\tau )\) is \(1\) if \(NS_t(\tau ) \ge 1\), otherwise \(0\). \(\gamma _t(\tau )\) is \(1\) if \(NC_t(\tau ) \ge 1\), otherwise \(0\).
The total power consumption \(TE_t(st\), \(et)\) (Ws) of a server \(s_t\) from time \(st\) to time \(et\) is given as follows:
$$\begin{aligned} TE_t (st, et) = \int _{st}^{et} E_t(\tau ) \mathrm{d} \tau . \end{aligned}$$
(2.2)
An idle server \(s_t\) consumes electric power at rate \(minE_t\). The unused power consumption \(UE_t(st, et)\) (Ws) and effective power consumption \(EE_t(st, et)\) (Ws) of a server \(s_t\) from time \(st\) to \(et\) are given as follows:
$$\begin{aligned} UE_t(st,et)&= \int _{st}^{et} \pi _t(\tau ) \cdot minE_t \mathrm{d} \tau . \end{aligned}$$
(2.3)
$$\begin{aligned} EE_t(st, et)&= TE_t(st,et) - UE_t(st, et). \end{aligned}$$
(2.4)
Here, \(\pi _t(\tau )\) is \(1\) if \(N_t(\tau ) = 0\), otherwise \(0\). As presented in the paper [13], about 85 % of the total power consumption of servers is unused.

It takes \(minT_{ti}\) (s) to perform a CP process \(p_i\) on a server \(s_t\) without any other processes. It takes \(T_{ti}\) (s) to perform a process \(p_i\) on a server \(s_t\). \(minT_{ti} \le T_{ti}\). Let \(minT_i\) be minimum\((\{minT_{ti}\)\(|\)\(s_t\)\(\in \)\(S\})\). \(minT_i\) (s) stands for the total amount of computation of a process \(p_i\). In this paper, \(minT_i\) is assumed to be a priori known for every CP process \(p_i\). The maximum computation rate \(maxF_{ti}\) is \(minT_i/minT_{ti}\)\((\le 1)\). For every pair of different processes \(p_i\) and \(p_j\), \(maxF_{ti} = maxF_{tj} = maxF_t\). Here, \(maxF_t\) shows the maximum computation rate of a server \(s_t\)\((0 < maxF_t \le 1)\).

If \(NC_t(\tau _1) > NC_t(\tau _2)\), \(\alpha _t(\tau _1) < \alpha _t(\tau _2)\). In this paper, we assume the computation rate \(F_t(\tau )\) of a server \(s_t\) is fairly allocated to every concurrent process \(p_i\) in the set \(CCP_t(\tau )\) at time \(\tau \) :
$$\begin{aligned} F_{ti}(\tau ) = \alpha _t(\tau ) \cdot maxF_t / NC_t(\tau ). \end{aligned}$$
(2.5)
Here, the degradation factor \(\alpha _t(\tau ) \!=\! \epsilon _t^{NC_t(\tau ) - 1}\) where \(0<\epsilon _t\le 1\). \(F_{ti}(\tau ) \!=\! F_{tj}(\tau )\) for every pair of CP processes \(p_i\) and \(p_j\) concurrently performed on a server \(s_t\) at time \(\tau \).

When a CP process \(p_i\) starts on a server \(s_t\), the computation laxity \(lc_{ti}\) is \(minT_i\) (s). At each unit time \(\tau \), the computation laxity \(lc_{ti}\) of a process \(p_i\) is decremented by \(F_{ti}(\tau )\), i.e. \(lc_{ti} = lc_{ti} - F_{ti}(\tau )\). If the computation laxity \(lc_{ti}(\tau )\) gets 0 at time \(\tau \), the process \(p_i\) terminates.

2.2 Access rate

An ST process \(p_i\) accesses a file of size \(b_i\) (bit) in a server \(s_t\). In this paper, we assume each ST process \(p_i\) either reads or writes a file \(f_i\). Every server \(s_t\) holds a full replica of a file \(f_i\) to be manipulated by each ST process \(p_i\). For every pair of ST processes \(p_i\) and \(p_j\), \(f_i \ne f_j\). A process \(p_i\) reads a file \(f_i\) at rate \(RR_{ti}(\tau )\) and writes a file \(f_i\) at rate \(WR_{ti}(\tau )\) at time \(\tau \). The access rate \(AR_{ti}(\tau )\) of a server \(s_t\) at time \(\tau \), i.e. \(RR_{ti}(\tau )\) or \(WR_{ti}(\tau )\) is given as follows (2.6):
$$\begin{aligned} {AR}_{ti}(\tau )=\left\{ \begin{array}{ll} {maxAR}_t / [{NS}_t(\tau ) \cdot {NC}_t(\tau )] \quad \mathrm{if}\, NC_t(\tau ) > 0 \\ maxAR_t / NS_t(\tau ) \quad \mathrm{if}\, NC_t(\tau ) = 0.\\ \end{array} \right. \end{aligned}$$
(2.6)
The maximum access rate \(maxAR_{ti}\) is \(b_i / minT_{ti}\) (bps). Here, it is noted \(maxAR_{ti} = maxAR_{tj} = maxAR_t\) for every pair of ST processes \(p_i\) and \(p_j\). \(maxAR_t\) stands for the maximum access rate of a server \(s_t\).

When an ST process \(p_i\) starts on a server \(s_t\), the storage laxity \(ls_{ti}\) is size \(b_i\) (bit) of a file \(f_i\). At each unit time \(\tau \), the storage laxity \(ls_{ti}\) is decremented by the access rate \(AR_{ti}(\tau )\) (bps), i.e. \(ls_{ti} = ls_{ti} - AR_{ti}(\tau )\). If the storage laxity \(ls_{ti}\) gets 0, the process \(p_i\) terminates on the server \(s_t\).

Figure 2 shows how the execution times of a CP process and an ST process depend on one another in the experimentations [11]. A node shows a type of a process, i.e. \(CP\) and \(ST\). A directed edge \(\alpha \rightarrow \beta \) indicates that the execution time of an \(\alpha \) process depends on the execution time of a \(\beta \) process. That is, the execution time of a CP process depends on the number of concurrent CP processes but is independent of ST processes. The execution time of an ST process depends on the number of concurrent ST and CP processes.
Fig. 2

Execution time dependency of processes

2.3 Power laxity

In this paper, a load balancer \(L\) is assumed to know which process is performed on each server \(s_t\) at every time \(\tau \), i.e. sets \(CCP_t(\tau )\) and \(CST_t(\tau )\). First, the expected computation laxity \(elc_{ti}\) and the expected storage laxity \(els_{ti}\) of a process \(p_i\) performed on a server \(s_t\) at time \(\tau \) are assumed to be given as follows:
  1. 1.

    \(elc_{ti} = minT_i/mc_t\) (s).

     
  2. 2.

    \(els_{ti} = b_i / ms_t\) (bit).

     
Here, \(mc_t\) and \(ms_t\) are laxity estimation parameters, \(0 < mc_t \le 1\) and \(0 < ms_t \le 1\). In this paper, we assume \(mc_t = ms_t = 1/2\).
The expected time to perform every process is given by EtimeCCP (\(CCP_t(\tau )\), \(s_t, \tau \)) \(+\)EtimeST\((CST_t(\tau ), CCP_t(\tau ), s_t, \tau , ct)\):
Suppose a process \(p_i\) is issued to a server \(s_t\). The estimated power laxity \(lpc_t(\tau )\) to perform every process and the new process \(p_i\) at time \(\tau \) is computed by the following procedure EPower\((CCP_t(\tau ), CST_t(\tau ), s_t, \tau )\):

3 Energy-aware clusters

3.1 Server state

In our previous studies [13], the energy-aware (EA) algorithm is discussed to select a server in a cluster \(S\) of fixed servers for each request so that the total power consumption of the servers can be reduced and the total execution time of processes is not increased compared with the round-robin (RR) and random (R) algorithms. A server \(s_t\) where at least one process is performed is referred to as active. A server \(s_t\) where no process is performed is referred to as idle. An idle server \(s_t\) just consumes electric power at minimum rate \(minE_t\) even if no process is performed as discussed in the SCBPC model. In papers [2] and [5], the power consumption rates \(minE_t\), \(ST_t\), \(C_t\), and \(STC_t\) of a server \(s_t\) are shown to be 101, 108, 168, and 176 W, respectively. Thus, \(minE_t\) is more than half of the maximum power consumption rate \(STC_t\) where both ST and CP process are performed and is about two-third of \(C_t\) where only CP processes are performed. The more number of idle servers, the more amount of unused power is consumed in a cluster. It is critical to reduce the unused power consumption of servers in a cluster in addition to reducing the effective power consumption of active servers.

An active server consumes electric power at rate depending on types of processes performed as shown in formula (2.1) discussed in the SCBPC model. In this paper, we discuss states of an active server \(s_t\) in terms of number \(N_t(\tau )\) of concurrent processes performed at time \(\tau \). A server \(s_t\) is referred to as in lightly loaded (\(L\)), well working (\(W\)), heavily loaded (\(H\)), and overloaded (\(O\)) states at time \(\tau \) iff (if and only if) \(0 < N_t(\tau ) \le LL_t\), \(LL_t \le N_t(\tau ) < WW_t\), \(WW_t \le N_t(\tau ) < HL_t\), \(HL_t \le N_t(\tau ) < OL_t\), and \(OL_t \le N_t(\tau )\), respectively. \(LL_t\), \(WW_t\), \(HL_t\), and \(OL_t\) are constants showing the numbers of processes to be concurrently performed on a server \(s_t\) where \(0 < LL_t < WW_t < HL_t < OL_t\). Let \(\sigma (s_t)\) show a state of a server \(s_t\), i.e. \(\sigma (s_t) \in \)\(\{I,\)\(L,\)\(W,\)\(H,\)\(O\}\). As presented here, a server \(s_t\) is active iff \(s_t\) is lightly loaded, well working, heavily loaded, or overloaded. The state \(\sigma (s_t)\) of a server \(s_t\) is transited to another state depending on the number \(N_t(\tau )\) of concurrent processes.

A state transition diagram of a server \(s_t\) is shown in Fig. 3. Here, a node \(\alpha \) shows a state \(\alpha \in \{I, L, W, H, O\}\) of a server \(s_t\). A directed edge \(\alpha _1 \rightarrow \epsilon (\theta \beta ) \alpha _2\) from a node \(\alpha _1\) to a node \(\alpha _2\) indicates that a server state \(\sigma (s_t)\) is transited from a state \(\alpha _1\) to a state \(\alpha _2\) if an event \(\epsilon \) occurs and the condition \(N_t(\tau )\)\(\theta \)\(\beta \) is satisfied at the state \(\alpha _1\). Here, \(\epsilon \in \{+, -\}\) where \(+\) and \(-\) stand for events that a process is started and terminated on a server \(s_t\), respectively. In the state transition condition, \(\theta \in \{<, \le , =, \ge , >\}\) and \(\beta \in \{0, LL_t, WW_t, HL_t, OL_t\}\). Suppose a server \(s_t\) is lightly loaded, i.e. \(\sigma (s_t) = L\), and a new process is started on the server \(s_t\) at time \(\tau \). Here, \(N_t(\tau )\) is incremented by one. If \(N_t(\tau ) \ge LL_t\), a state \(\sigma (s_t)\) of the server \(s_t\) is transited from a state \(L\) to a state \(W\), i.e. \(L \rightarrow {+ (\ge LL_t)} W\). If a server \(s_t\) is overloaded (\(O\)), i.e. \(\sigma (s_t) = O\), no new process cannot be performed on the server \(s_t\). Next, suppose a process terminates on a server \(s_t\) at time \(\tau \). \(N_t(\tau )\) is decremented by one. Here, if \(N_t(\tau ) < WW_t\) at time \(\tau \), the state \(\sigma (s_t)\) is transited from a state \(W\) to a state \(L\), i.e. \(W \rightarrow {- (< WW_t)} L\) If \(N_t(\tau ) = 0\), i.e. no process is performed, the server state \(\sigma (s_t)\) is transited to an idle (\(I\)) state.
Fig. 3

State transition diagram

3.2 Cluster states

A state \(\sigma (S_L)\) of a cluster \(S_L = \{s_1, \ldots , s_n\}\) is a collection \(\{\sigma (s_t) | s_t \in S_L\}\) of server states. A cluster state \(\sigma (S_L)\) is specified in a tuple \(\langle I^{a_{I}}, L^{a_{L}}, W^{a_{W}}, H^{a_{H}}, O^{a_{O}} \rangle \) where \(a_X \in \{*,\)\(+,\)\(0\}\) for a server state \(X\)\(\in \)\(\{I,\)\(L\), \(W,\)\(H,\)\(O\}\). For each server state \(X \in \{I,\)\(L,\)\(W,\)\(H,\)\(O\}\), \(X^{a_X}\) is defined as follows:
  1. 1.

    \(X^*\): There is more than or equal to zero server whose state is \(X\) in a cluster \(S_L\), i.e. \(|\{s_t | \sigma (s_t)=X\}| \ge 0\).

     
  2. 2.

    \(X^+\): There is at least one server whose state is \(X\) in a cluster \(S_L\), i.e. \(|\{s_t | \sigma (s_t) = X\}| \ge 1\).

     
  3. 3.

    \(X^0\): There is no server whose state is \(X\) in a cluster \(S_L\), i.e. \(|\{s_t | \sigma (s_t) = X\}| = 0\).

     
For example, a notation \(W^+\) means at least one server is well working (\(W\)) in a cluster \(S_L\). A notation \(H^0\) indicates that there is no highly loaded server in a cluster \(S_L\). A cluster state \(\sigma (S_L) = \langle I^0, L^*, W^+, H^0, O^0 \rangle \) shows that a cluster \(S_L\) is composed of at least one server in a \(W\) state and might include servers in an \(L\) state, and includes no \(I\), \(H\), and \(O\) server.
A cluster \(S_L\) is referred to as overloaded (\(O\)) if a cluster state \(\sigma (S_L)\) is \(\langle I^0, L^0, W^0, H^*, O^+ \rangle \). That is, every server \(s_t\) is overloaded or highly loaded, i.e. \(\sigma (S_L) = O\) or \(\sigma (S_L) = H\). A cluster \(S_L\) is underloaded (\(U\)) iff \(\sigma (S_L) = \langle I^*, L^*, W^0, H^0, O^0 \rangle \). Here, every server \(s_t\) is idle or lightly loaded, \(\sigma (s_t) = I\) or \(\sigma (s_t) = L\). A cluster \(S_L\) is well working (\(W\)) iff \(\sigma (S_L) = \langle I^0, L^*, W^*, H^*, O^0 \rangle \). Here, every server \(s_t\) is neither overloaded nor underloaded. A cluster \(S_L\) is partially working (\(P\)) if \(\sigma (S_L) = \langle I^0, L^+, W^*, H^0, O^0 \rangle \). Here, at least one server is lightly loaded and the other servers are lightly loaded or well working. The other cluster states like \(\langle I^+, L^0, W^0, H^*, O^+ \rangle \) than the cluster states \(O\), \(W\), \(P\) and \(U\) are referred to as unbalanced. If a cluster \(S_L\) is balanced, i.e. \(\sigma (S_L) \in \{O, W, P, U\}\), processes are fairly allocated to servers. That is, the difference \(|N_t(\tau ) - N_u(\tau )|\) of server loads is small for every pair of servers \(s_t\) and \(s_u\) in a balanced cluster \(S_L\). If a cluster \(S_L\) is unbalanced, processes are not fairly allocated to servers. For example, some server is overloaded while another server is idle. Table 1 shows the balanced cluster states.
Table 1

Balanced cluster states

Cluster states

\(I\)

\(L\)

\(W\)

\(H\)

\(O\)

Overloaded (\(O\))

\(0\)

\(0\)

\(0\)

\(*\)

\(+\)

Well working (\(W\))

\(0\)

\(*\)

\(*\)

\(*\)

\(0\)

Partially working (\(P\))

\(0\)

\(+\)

\(*\)

\(0\)

\(0\)

Underloaded (\(U\))

\(+\)

\(*\)

\(0\)

\(0\)

\(0\)

3.3 Dynamic clusters

We have to reduce the unused power consumption of idle servers in addition to the effective power consumption of active servers in order to reduce the total power consumption of the servers. One idea is to turn off idle servers and turn on servers if fewer number and more number of servers are required to perform processes, respectively, as discussed in the paper [14]. However, it takes time and spends electric power to turn on and off servers. Furthermore, server peers cannot be turned on and off by others different from the owners of the peers in peer-to-peer (P2P) overlay networks. In this paper, we take a dynamic cluster approach. First, there are a set \(A\) of possible servers distributed on a network. A free server distributed in networks is selected and invited to be a member of a cluster \(S_L\) if more number of servers are required to support clients with enough service like computation and database in the cluster \(S_L\). Servers leave a cluster \(S_L\) if too many number of servers are included. The membership of a server cluster \(S_L\) is thus dynamically changed so that only active servers are included and each server is fairly loaded in the cluster \(S_L\). A server which is not included in any cluster is referred to as free. Free servers are assumed to be idle in the system \(A\). A server is referred to as engaged iff the server is included in a cluster. In this paper, if a state \(\sigma (S_L)\) of a cluster \(S_L\) is overloaded and underloaded, a free server in the system \(A\) is invited and an idle server is excluded in the cluster \(S_L\) so that the cluster \(S_L\) gets well working (\(W\)).

First, we discuss how to exclude a server in a cluster \(S_L\). An idle server \(s_t\) is excluded in a cluster \(S_L\) if the cluster \(S_L\) is in an underloaded (\(U\)) state \(\langle I^+, L^*, W^*, H^0, O^0 \rangle \). That is, some number of servers are idle while the other servers are lightly loaded (\(L\)) or well working (\(W\)). Here, one idle server \(s_t\) is selected where the minimum power consumption rate \(minE_t\) is minimum in the idle servers. Then, the server \(s_t\) is excluded in the cluster \(S_L\). Here, the server \(s_t\) gets free in the set \(A\).

Next, if a cluster \(S_L\) is in a partially working (\(P\)) state, i.e. \(\langle I^0, L^+, W^*, H^0, O^0 \rangle \), one lightly loaded (\(L\)) server \(s_t\) is selected, where the minimum power consumption rate \(minE_t\) is maximum in the \(L\) servers. The load balancer \(L\) does not forward a request to the selected server \(s_t\). A server \(s_t\) where no new request is issued is referred to as partially active \((P)\). Thus, an \(L\) server \(s_t\) is selected and gets partially active if the cluster \(S_L\) is in a \(W\) state \(\langle I^0, L^+, W^*, H^0, O^0 \rangle \). In a \(P\) server \(s_t\), \(N_t(\tau )\) monotonically decreases each time \(\tau \) a process terminates. Then, the server \(s_t\) eventually gets idle. Here, a new element \(P\) standing for partially active \((P)\) servers is added to a cluster state \(\sigma (S_L)\). That is, a cluster state \(\langle I^0, L^+, W^*, H^0, O^0 \rangle \) is transited to another state \(\langle I^0, P^+, L^+, W^*, H^0, D^0\rangle \). If every process terminates on the server \(s_t\), the \(P\) server \(s_t\) gets idle. Here, the cluster state \(\sigma (S_L)\) is transited to \(\langle I^+, L^*, W^*, H^0, D^0\rangle \).

A new server \(s_t\) is invited to be a member of the cluster \(S_L\) if the cluster state \(\sigma (S_L)\) is overloaded (\(O\)), i.e. \(\langle I^0, L^0, W^0, H^*, O^* \rangle \). The cluster state \(\sigma (S_L)\) is transited to an \(O\) state \(\langle I^+, L^0, W^0, H^*, O^*\rangle \). If the cluster state \(\sigma (S_L)\) is \(\langle I^0, P^+, L^0, W^0, H^*, O^*\rangle \), a partially active (\(P\)) server \(s_t\) is selected and changed with an \(L\) state without inviting a new server.

3.4 DEA algorithm

We would like to discuss a dynamic energy-aware (DEA) algorithm to select a server for a request. Let \(A\) be a set of servers in networks. For example, a server set \(A\) is a collection of possible server peers in peer-to-peer (P2P) overlay networks. There is a load balancer \(L\) with a cluster \(S_L\) which is a subset of the system \(A\)\((S_L\)\(\subseteq \)\(A)\). Each server is assumed to be included in at most one cluster as shown in Fig. 4. Every client \(c_s\) sends a request \(q_s\) to the load balancer \(L\). On receipt of the request \(q_s\) from the client \(c_s\), the load balancer \(L\) not only selects a server \(s_t\) for the request \(q_s\) but also invites and excludes idle servers in a cluster \(S_L\). Initially, a cluster \(S_L\) is empty, i.e. \(S_L = \phi \) for each load balancer \(L\).
Fig. 4

Dynamic clusters

On receipt of a request \(q_s\) from a client \(c_s\), the load balancer \(L\) selects one server \(s_t\) in a cluster \(S_L\) as follows:
  1. 1.

    \(p_i\) shows a process of the request \(q_s\).

     
  2. 2.

    If \(S_L = \phi \), one free server \(s_t\) is selected in the system \(A\), where the expected power laxity to perform the process \(p_i\) is minimum in the system \(A\). The expected power laxity is calculated by the function EPower discussed in the preceding section.

     
  3. 3.

    If the cluster \(S_L\) is well working or lightly loaded, i.e. \(\sigma (S_L) = W\) or \(\sigma (S_L) = L\), one server \(s_t\) whose expected power laxity is minimum is selected in the cluster \(S_L\).

     
  4. 4.

    If the cluster \(S_L\) is overloaded with no partially active server, i.e. \(\sigma (S_L) = O\), one free, i.e. idle server \(s_t\) in the system \(A\) is invited to be a member of the cluster \(S_L\). Then, the server \(s_t\) is selected for the request \(q_s\) in the cluster \(S_L\).

     
  5. 5.

    If the cluster \(S_L\) is overloaded with partially active servers, one partially active server \(s_t\) whose expected power laxity is minimum out of the partially active servers is selected. Here, the server \(s_t\) is changed with an \(L\) state.

     
Then, the load balancer \(L\) forwards the request \(q_s\) to the selected server \(s_t\). The process \(p_i\) is created for the request \(q_s\) and performed on the server \(s_t\). Then, the server \(s_t\) sends a reply \(r_s\) of the request \(q_s\) to the client \(c_s\).
Next, suppose a process \(p_i\) is terminated on a server \(s_t\) in the cluster \(S_L\). The server \(s_t\) also sends a termination notification message \(t_s\) to the load balancer \(L\) (Fig. 5).
Fig. 5

Terminate notification

The load balancer \(L\) obtains information on how many number \(N_t(\tau )\) of processes are being performed on each server \(s_t\) at time \(\tau \). The load balancer \(L\) decides on a state \(\sigma (s_t)\) of each server \(s_t\) using the information on \(N_t(\tau )\). On receipt of the notification message from a server \(s_t\), the load balancer \(L\) behaves at time \(\tau \) as follows:
  1. 1.

    The load balancer \(L\) updates the server state \(\sigma (s_t)\) by decrementing the number \(N_t(\tau )\) by one. Then, the cluster state \(\sigma (S_L)\) is obtained.

     
  2. 2.

    If the cluster \(S_L\) is underloaded, i.e. \(\sigma (S_L) = U\), one idle server \(s_t\) whose \(minE_t\) is maximum in the idle servers is excluded in the cluster \(S_L\).

     
  3. 3.

    If the cluster \(S_L\) is in a \(P\) state \(\langle I^0, L^+, W^*, H^0, O^0\rangle \), one \(L\) server \(s_t\) whose \(minE_t\) is maximum is changed with a \(P\) state. That is, the cluster state \(\sigma (S_L)\) is transited to a \(P\) state \(\langle I^0, P^+, L^*, W^*, H^0, O^0\rangle \).

     

4 Evaluation

4.1 Environment

We evaluate the DEA algorithm to select a server for a request in a dynamic cluster \(S_L\) of possible servers \(s_1, \ldots , s_n\) in terms of the total power consumption (Ws) and total execution time (s) to perform the total number \(m\) of processes. There are ten servers \(s_1, \ldots , s_n\)\((n = 10)\), i.e. \(A = \{s_1, \ldots , s_{10}\}\) in this evaluation. Each server \(s_t\) supports the maximum computation rate \(maxF_t\) (s) and read access rate \(maxRR_t\) (bps). In this evaluation, the maximum computation rate \(maxF_t\) is given to be in a random number out of 0.7, 0.8, 0.9, and 1.0. Here, \(maxF_1 = 1.0\) and \(maxF_{10} = 0.7\). That is, the server \(s_1\) is the fastest and the server \(s_{10}\) is the slowest. Each server \(s_t\) is randomly given \(maxF_t\) (\(t = 2, \ldots , 9\)). \(\epsilon _t\) is 0.99. The minimum power consumption rate \(minE_t\) of a server \(s_t\) is randomly decided so that \(90 \le minE_t \le 110\) (W). \(c_t\) and \(d_t\) are also randomly selected in ranges of \(70, 71, \ldots , 90\) and of \(10, 11, \ldots , 20\) (W). In this simulation, \(LL_t\), \(WL_t\), \(HL_t\), and \(OL_t\) are given as \(LL_t = 40\), \(WL_t = 80\), \(HL_t = 124\), and \(OL_t = 125\) for each server \(s_t\).

We only consider an ST process \(p_i\) which reads a file \(f_i\) for simplicity. The size \(b_i\) of each file \(f_i\) to be read by an ST process \(p_i\) is randomly taken in 100, 250, and 500 (MB). The maximum read rate \(maxRR_t\) of each server \(s_t\) is randomly selected in a set of rates \(70, 71, \ldots , 85\) (MB/s). For each CP process \(p_i\), the computation laxity \(lc_i\) stands for the total amount of computation (s) of the CP process \(p_i\). The minimum computation time \(minT_i\) of each CP process \(p_i\) is randomly taken out of 1, 2, 4 (s). Initially, \(lc_i = minT_i\).

The total evaluation time is 9,000 s. One unit time is 100 ms because the power consumption can be measured on every 100 ms [5, 6, 10, 11]. That is, the total evaluation time is a sequence of 90,000 time units. The total number \(m\) of processes \(p_1, \ldots , p_m\) is randomly generated. For each process \(p_i\), starting time \(st_i\) when to start the process \(p_i\) is randomly decided in the 90,000 time units. Then, a type \(tp_i\) of each process \(p_i\) is also randomly selected so that a CP process and ST process are created with probably 1/3 and 2/3, respect6ively. The simulation finishes when every process terminates after 90,000 time unites.

Three algorithms, round-robin (RR), random (R), and the energy-aware (EA) algorithms [13], are used to select servers for requests in the same traffic pattern. In the RR algorithm, the servers \(s_1, \ldots , s_{10}\) are totally ordered in the maximum power consumption rate. That is, \(minE_t + c_t + d_t \le minE_u +c_u + d_u\) for \(t < u\). First, a process \(p_i\) is sent to the server \(s_1\). If the server \(s_1\) is overloaded, the process \(p_i\) is sent to the server \(s_2\). Thus, if a server \(s_t\) is overloaded, the process \(p_i\) is sent to a server \(s_{t+1}\). In the R algorithm, a server \(s_t\) is randomly selected in the server set \(S\). If the selected server \(s_t\) is overloaded for the process \(p_i\), another server \(s_t\) is randomly selected in a server set \(S - \{s_t\}\). Until a server \(s_t\) which is not overloaded is selected, the procedure is iterated.

4.2 Evaluation results

Figure 6 shows the total execution time (s) of \(m\) processes in the R, RR, EA, and DEA algorithms. The execution time in the DEA algorithm is 5–10 % longer than the other algorithms for \(m < 1{,}200\). In the DEA algorithm, the number of servers in a cluster is smaller than the other algorithms. More number of processes are concurrently performed on each active server in the DEA algorithm. Hence, the total execution time of the DEA algorithm is higher.
Fig. 6

Execution time

Figure 7 shows the total energy (Ws) consumed by servers for total number \(m\) of processes in the R, RR, EA, and DEA algorithms. The total power consumption of servers in the cluster \(S_L\) is smaller than the other algorithms, especially for smaller number \(m\) of processes. For example, the total power consumption of the dynamic cluster is about 30 and 75 % of the other algorithms for \(m = 5{,}000\) and \(m = 15{,}000\), respectively.
Fig. 7

Total energy

Figure 8 shows the average number and maximum number of servers included in a dynamic cluster. For example, only at most four servers are included in the dynamic cluster for \(m = 5{,}000\). In the most heavily loaded situation for \(m \ge 15{,}000\), seven to eight servers are on average included in the dynamic cluster. In the other algorithms, ten servers are always included in a cluster. In addition, the average numbers of \(I\), \(L\), \(W\), \(H\), and \(O\) servers in the dynamic cluster are shown in Fig. 8. There is no idle server in the dynamic cluster. At most one server is overloaded and most servers are in \(L\), \(W\), and \(H\) states in the DEA algorithm. That is, dynamic clusters are well balanced.
Fig. 8

Maximum and average numbers of servers

Figure 9 shows the average numbers of idle (\(I\)) servers in the R, RR, EA, and DEA algorithms. In the R, RR, and EA algorithms, the more the lightly loaded, the more number of idle (\(I\)) are servers in a cluster. For example, about 80 % of the servers are idle for \(m = 1,\!000\). In the DEA algorithm, the number of \(I\) server is reduced to be zero compared with the EA algorithm.
Fig. 9

Average number of \(I\) servers

Figure 10 shows the average number of processes performed on each server in a cluster. In the other algorithms, a cluster includes always 10 servers (\(n = 10\)). Hence, the average number of processes is \(m/n = m/10\) for the number \(m\) of processes. In the DEA algorithm, totally about 2,000 processes are on average performed on each server for number \(m\) (\(>\)5,000) of processes. Each server is more loaded in the DEA algorithm than the other algorithms.
Fig. 10

Average number of processes on each server

5 Concluding remarks

As discussed in the storage- and computation-based power consumption (SCBPC) model of a server, an idle server \(s_t\) consumes electric power at minimum rate \(minE_t\) if no process is performed. The minimum power consumption rate \(minE_t\) is larger than half of the maximum power consumption rate of a server \(s_t\). It is critical to reduce the unused consumption of idle servers. In this paper, we discussed a dynamic cluster on P2P overlay networks which includes only active servers and no idle servers. We discussed the dynamic energy-aware (DEA) algorithm to select a server \(s_t\) for each request from a client in a dynamic cluster. Through the evaluation, we show the total power consumption in a cluster can be reduced in the DEA algorithm compared with the RR, R, and EA algorithms. A dynamic cluster does not include idle servers. However, the total execution time is 5–10 % longer than the EA and RR algorithm. We are now trying to increase the performance of the DEA algorithm.

References

  1. 1.
    Waluyo A, Rahayu W, Taniar D, Srinivasan B (2011) A novel structure and access mechanism for mobile broadcast data in digital ecosystems. IEEE Trans Ind Electron 58(6):2173–2182CrossRefGoogle Scholar
  2. 2.
    Enokido T, Suzuki K, Aikebaier A, Takizawa M (2010) Process allocation algorithm for improving the energy efficiency in distributed systems. In: Proceedings of IEEE the 24th international conference on advanced information networking and applications (AINA-2010), pp 142–149Google Scholar
  3. 3.
    Enokido T, Aikebaier A, Takizawa M (2011) Process allocation algorithms for saving power consumption in peer-to-peer systems. IEEE Trans Ind Electron 58(6):2097–2105CrossRefGoogle Scholar
  4. 4.
    Enokido T, Takizawa M (2012) An extended power consumption model for distributed applications. In: Proceedings of IEEE the 26th international conference on advanced information networking and applications (AINA-2012), pp 912–919Google Scholar
  5. 5.
    Inoue T, Ikeda M, Enokido T, Aikebaier A, Takizawa M (2011) A power consumption model for storage-based applications. In: Proceedings of the fifth international conference on complex, intelligent, and software intensive systems (CISIS-2011), pp 612–617Google Scholar
  6. 6.
    Inoue T, Enokido T, Aikebaier A, Takizawa M (2011) A power consumption model of a storage server. In: Proceedings of the 14-th international conference on network-based information systems (NBiS-2011), pp 382–387Google Scholar
  7. 7.
    Enokido T, Aikebaier A, Takizawa M (2010) A model for reducing power consumption in peer-to-peer systems. IEEE Syst J 4(2):221–229CrossRefGoogle Scholar
  8. 8.
    Enokido T, Aikebaier A, Deen SM, Takizawa M (2010) Power consumption-based server selection algorithms for communication-based systems. In: Proceedings of the 13th international conference on network-based information systems (NBiS-2010), pp 201–208Google Scholar
  9. 9.
    Ghobadi A, Eswaran C, Muthuvelu N, Tan IKT, Kee YL (2009) An adaptive wrapper algorithm for file transfer applications to support optimal large file transfers. In: Proceedings of IEEE the 11th international conference on advanced communication technology (ICACT 2009), pp 315–320Google Scholar
  10. 10.
    Inoue T, Aikebaier A, Enokido T, Takizawa M (2012) Algorithms for selecting energy-efficient storage servers in storage and computation oriented applications. In: Proceedings of IEEE the 26th international conference on advanced information networking and applications (AINA-2012), pp 217–224Google Scholar
  11. 11.
    Inoue T, Aikebaier A, Enokido T, Takizawa M (2012) Energy-aware distributed systems for computation and storage-based applications, In: Proceedings of the 6th international conference on complex, intelligent, and software intensive systems (CISIS-2012), CD-ROMGoogle Scholar
  12. 12.
    Dong H, Hussain FK, Chang E (2010) Semantic service retrieval and QoS measurement in the digital ecosystem environment. In: Proceedings of the complex, intelligent, and software intensive systems (CISIS-2010), pp 153–160Google Scholar
  13. 13.
    Inoue T, Aikebaier A, Enokido T, Takizawa M (2012) Energy-aware distributed systems for computation and storage-based applications. In: Proceedings of the 7th international conference on broadband and wireless computing, communication and applications (BWCCA-2012), CD-ROMGoogle Scholar
  14. 14.
    Bianchini R, Rajamony R (2004) Power and energy management for server systems. Computer 37(11):68–76CrossRefGoogle Scholar

Copyright information

© Springer Science+Business Media New York 2014

Authors and Affiliations

  • Dilawaer Duolikun
    • 1
  • Tomoya Enokido
    • 2
  • Ailixier Aikebaier
    • 3
  • Makoto Takizawa
    • 1
  1. 1.Hosei UniversityKoganeiJapan
  2. 2.Rissho UniversityShinagawaJapan
  3. 3.National Institute of Information and Communications TechnologyKoganeiJapan

Personalised recommendations