An extended power consumption-based algorithm for communication-based applications

Abstract

In information systems, it is critical to reduce the total electrical power consumption of computers and networks in order to realize the eco society. In our previous studies, a pair of PCB (power consumption-based) and TRB (transmission rate-based) algorithms are proposed to select one of servers so that the total power consumption of the servers is reduced for communication-based applications. In addition, the PCB algorithm is shown to be more useful for reducing the total power consumption than the TRB one. However, we consider only how much amount of electric power a server is expected to consume to transmit a file to a new requesting client in the PCB algorithm. Here, the server might be transmitting files to other clients. Therefore, we have to estimate the power consumption to transmit a file to a new client by considering how much power consumption the server would spend to transmit files to other clients. In this paper, we newly propose an extended power consumption-based (EPCB) algorithm by improving the PCB algorithm by taking into consideration how much power a server consumes to transmit files to every requesting client. In the evaluation, we show the total power consumption of servers can be more reduced by the EPCB algorithm than the PCB and TRB algorithms.

1 Introduction

In the green IT technologies [Green IT, http://www.greenit.net (2010)], the total electric power consumption of computers and networks are required to be reduced. There are various kinds of applications on distributed systems. We classify applications into two types; transaction-based and communication-based network applications. In the papers (Aikebaier et al. 2009; Enokido et al. 2010a, c; Yang et al. 2009), it is discussed how to reduce the power consumption of servers in transaction-based applications like Web applications

In another type of application like the file transfer protocol (FTP), a large volume of data is transmitted by a server to a client. In the papers (Enokido et al. 2009, 2010b), we discussed a power consumption model for transmitting files from servers to clients where the electric power consumption of the server to transmit a file to a client depends on the transmission rate of the server on the experimental results (Enokido et al. 2009). Here, a pair of PCB (power consumption-based) and TRB (transmission rate-based) algorithms are proposed to select a server in a set of servers so that the total power consumption can be reduced. In the evaluation (Enokido et al. 2010b), the total power consumption and the total transmission time are shown to be reduced in the PCB and TRB algorithms compared with the traditional round-robin (RR) algorithm [Weighted Least Connection (WLC), http://www.linuxvirtualserver.org/docs/scheduling.html (1998); Weighted Round Robin (WRR), http://www.linuxvirtualserver.org/docs/scheduling.html (1998)]. The PCB algorithm is more useful than TRB algorithm since it is difficult to estimate the transmission rates to each client in the TRB algorithm.

Suppose a server s _t transmits a file f to a requesting client c _s at time τ. In the PCB algorithm, it is discussed only how much power the server s _t consumes to transmit a file f to the client c _s . However, there might be some clients receiving files from the server s _t . Therefore, we have to estimate how much amount of power the server s _t consumes to transmit files not only to the new requesting client c _s but also current clients which are receiving files from the server s _t . In this paper, we newly propose an extended power consumption-based (EPCB) algorithm by improving the PCB algorithm by taking into consideration how much power a server consumes to transmit a file to every requesting client. We evaluate the EPCB algorithm in terms of the total power consumption and total transmission time of the servers compared with the PCB and TRB algorithms. We show the total power consumption can be more reduced than the PCB and TRB algorithms.

In Sect. 2, we show the system model. In Sect. 3, we show the experimental results of the total power consumption in file transfer applications and the power consumption model. In Sect. 4, we discuss how to select a server for downloading a file to reduce the total power consumption. In Sect. 5, we evaluate the EPCB algorithm compared with the TRB and PCB algorithms.

2 System model

There are a set S of multiple servers $s_1,\ldots, s_n$ ($n \geq1$), each of which holds a full replica of a file f. There are a set C of clients $c_1,\ldots, c_m$ ($m \geq 1$) which issue file transmission request to servers in S. A client c _s sends a transfer request of the file f to a load balancer K. Then, the load balancer K selects one server s _t in the server set S. The server s _t transmits the file f to the requesting client c _s as shown in Fig. 1.

Fig. 1

FTP model

We assume that a server s _t sends at most one file to each client at same time. We discuss how to select a server in the server set S for a client c _s so that the following constraints are satisfied:

• 1. The deadline constraint, i.e. the file has to be delivered to the requesting client c _s in some time units.

• 2. The power consumption of a selected server s _t to transfer the file f has to be minimized.

Suppose a server s _t concurrently transmits files $f_1, \ldots,f_m$ to a set C _t of clients $c_{1}, \ldots, c_{m}$ at rates $\hbox{tr}_{t1} (\tau), \ldots, \hbox{tr}_{tm}(\tau) (m \geq 1),$ respectively, at time τ. Let b _ts show the maximum network bandwidth [bps] between a server s _t and a client c _s . Let Maxtr _t be the maximum transmission rate [bps] of the server s _t ($\leq b_{ts}$) which is smaller than the network bandwidth b _ts . Here, the total transmission rate tr _t (τ) of the server s _t at time τ is given as $\hbox{tr}_t(\tau) = \hbox{tr}_{t1}(\tau) + \cdots +\hbox{tr}_{tm}(\tau).$ Here, $0 \leq \hbox{tr}_t(\tau) \leq \hbox{Maxtr}_t.$

Each client c _s receives messages of a file f _s at receipt rate rr _s (τ) at time τ. Let Maxrr _s indicate the maximum receipt rate of the client c _s . Here, $\hbox{rr}_s(\tau) \leq \hbox{Maxrr}_s.$ We assume each client c _s receives a file from at most one server at rate $\hbox{Maxrr}_s (=\hbox{rr}_s(\tau)).$ The server s _t allocates a client c _s with transmission rate tr _ts (τ) so that $\hbox{tr}_{ts}(\tau) \leq \hbox{Maxrr}_s$ at time τ.

Let T _ts be the total transmission time of a file f _s from a server s _t to a client $c_s (s = 1, \ldots, m).$ If the server s _t sends files to other clients concurrently with the client c _s , the transmission time T _ts is increased. Let minT _ts show the minimum transmission time $|f_s| / \hbox{min}(\hbox{Maxrr}_s, \hbox{Maxtr}_t)$ [s] of a file f _s from a server s _t to a client c _s where |f _s | indicates the size [bit] of the file f _s . $T_{ts} \geq\hbox{min}T_{ts}.$

Let tr _ts (τ) be the transmission rate of a file f _s from the server s _t to the client c _s at time τ. Suppose the server s _t starts and ends transmitting a file f _s to the client c _s at time st and et, respectively. Here, $\int_{st}^{et}\hbox{tr}_{ts}(\tau) d\tau = |f_s|$ and the transmission time T _ts is (et − st). If the server s _t sends only the file f _s to the client c _s at time $\tau, \hbox{tr}_{ts}(\tau) = \hbox{min}(\hbox{Maxtr}_t, \hbox{Maxrr}_s)$ [bps].

The laxity l _ts (τ) of transmission time is $|f_s| -\int_{\tau}^{et} \hbox{tr}_{ts}(x) dx$ [bit] at time τ, i.e. how many bits of the file f _s the server s _t still has to transmit to the client c _s at time τ.

There are types of computers with respect to the transmission rate. Let C _t (τ) be a set of clients $c_1, \ldots, c_m$ to which the server s _t transmits files $f_1, \ldots, f_m,$ respectively, at time τ. First, we consider a model where a server s _t satisfies the following properties:

[Server-bound model] If $\hbox{Maxrr}_{1} + \cdots + \hbox{Maxrr}_{m} \geq\hbox{Maxtr}_t, \sum_{c_{ts} \in C_t(\tau)}\hbox{tr}_{ts}(\tau) = d(\tau) \cdot\hbox{Maxtr}_t$ for every time τ.

Here, d(τ) ($\leq 1$) is the degradation factor. In this paper, we assume $d(\tau) = \gamma^{(1-|C_t(\tau)|)} (0 < \gamma \leq 1)$ at time τ. The more number of clients a server s _t transmits files, the longer it takes. Here, the effective transmission rate of the server s _t is $d(\tau)\cdot \hbox{Maxtr}_t.$ The more number of clients a server concurrently sends files, the smaller effective transmission rate.

Let us consider three files $f_1,\; f_2,$ and f ₃ which a server s _t sends to clients $c_1,\; c_2,$ and c ₃, respectively, as an example. First, suppose that the server s _t serially sends the files $f_1,\; f_2,$ and f ₃ to the clients $c_1,\; c_2,$ and c ₃, i.e. $et_1 = st_2$ and $et_2 = st_3$ as shown in Fig. 2. Here, the transmission time T _t is $et_3 - st_1 = \hbox{min}T_{t1} + \hbox{min}T_{t2} +\hbox{min}T_{t3}.$ Next, suppose the server s _t starts transmitting three files $f_1, f_2,$ and f ₃ at time st and terminates at time et as shown in Fig. 2(2). Here, since three files are concurrently transmitted, C _t (t) = 3 and $\gamma^{-2}\cdot T_t=\hbox{min}T_{t1} + \hbox{min}T_{t2} + \hbox{min}T_{t3}.$ For γ = 0.98, it takes about 1.4% longer time than the serial transmission.

Fig. 2

Transmission time

On the other hand, we consider another environment where a client c _s cannot receive a file from a server s _t at the maximum transmission rate Maxtr _t , i.e. $\hbox{Maxrr}_{s} < \hbox{Maxtr}_t.$ Hence, the transmission rate tr _ts of the server s _t to a client c _s is the maximum receipt rate Maxrr _s of the client c _s .

[Client-bound model] If $\hbox{Maxrr}_1 + \cdots + \hbox{Maxrr}_m \leq\hbox{Maxtr}_t, \sum_{c_{ts} \in C_t(\tau)}\hbox{tr}_{ts}(\tau) = \hbox{Maxtr}_t \cdot(\hbox{Maxrr}_1 + \cdots + \hbox{Maxrr}_m) / \hbox{Maxtr}_t$ for every time τ.

Even if every client c _s receives a file at the maximum rate Maxrr _s , the effective transmission rate is not degraded, i.e. d _t (τ) = 1.

3 Power consumption model

The amount of electric power a server consumes to transfer files to client is measured by using the power meter Watts up?.Net [Watts up? Net, http://www.wattsupmeters.com/secure/products.php?pn=0 (2009)] in the paper (Enokido et al. 2010b). Here, the power consumption of each server can be measured every one second. Two servers s ₁ and s ₂ are measured as shown in Table 1. For each server s _t , two types of experimentation environments, one-client ($1\hbox{C}_t$) and two-client ($2\hbox{C}_t$) environments (t = 1, 2) are considered. In the $1\hbox{C}_t$ environment, one client, say c ₁ downloads the file f from the server s _t . In the $2\hbox{C}_t$ environment, a pair of the clients c ₁ and c ₂ concurrently download the file f from the server s _t . A server s _t consumes the electric power to transmit files to clients while clients consume less amount of electric power. The power consumption rate shows the electric power consumption for a second (W/s). In the $1\hbox{C}_1$ environment, the server s ₁ transmits a file f to one client, say c ₁ at rate tr₁₁. Here, the server s ₁ is composed of one one-core CPU. The maximum transmission rate Maxtr₁ is 160 Mbps in the network of bandwidth b ₁₁ = 1G [bps]. In the $2\hbox{C}_1$ environment, the server s ₁ concurrently transmits the file f to a couple of clients c ₁ and c ₂. Here, $\hbox{tr}_1 = \hbox{tr}_{11} + \hbox{tr}_{12}.$ At the higher rate tr₁ the server s ₁ transmits the file f, the larger amount of power consumption the server s ₁ consumes. We obtain the approximated formula PC ₁(tr) to show the power consumption rate of a server s ₁ for total transmission rate tr [Mbps] by using the least-squares method to the experimental results:

Table 1 Servers

$$ PC_t(tr) = \beta_t(m) \cdot \alpha_t \cdot tr + \hbox{min}E_t. $$

(1)

Here, α _t is the power consumption to transmit one Mbits [W/Mb] for the $1\hbox{C}_t$ environment. α _t depends on a server type s _t . In Table 2, parameters obtained by the experiments are shown. m shows the number of clients in a server. β _t (m) shows how much power consumption is increased for the number m of clients, $\beta_t(m) \geq 1$ and $\beta_t(m) \geq\beta_t(m - 1).$ There is a fixed point maxm _t such that $\beta_t(\hbox{max}m_t - 1) \leq \beta_t(\hbox{max}m_t) = \beta_t(\hbox{max}m_t + h)$ for h > 0. minE _t gives the minimum power consumption rate of the server s _t where no file is transmitted (Fig. 3). $\beta_t(\hbox{max}m_t)\cdot\alpha_t\cdot \hbox{Maxtr}_t + \hbox{min}E_t$ gives the maximum power consumption rate maxE _t of the server s _t .

Table 2 Parameters

Fig. 3

Power consumption rate of server s _t (W/s)

Let E _t (τ) show the electric power consumption rate of a server s _t at time τ (W/s) ($t = 1, \ldots, n$). maxE _t and minE _t indicate the maximum and minimum electric power consumption rates of a server s _t , respectively. Here, minE _t shows the power consumption rate of a server s _t which is in idle state. That is, $\hbox{min}E_t \leq E_t(\tau) \leq \hbox{max}E_t$ for every time τ. Let maxE and minE show $\hbox{max}(\hbox{max}E_1, \ldots, \hbox{max}E_n)$ and $\hbox{min}(\hbox{min}E_1, \ldots, \hbox{min}E_n),$ respectively. In this paper, we assume that only file transfer applications are performed on each server and each client issues at most one file transfer request at a time. The electric power consumption rate E _t (τ) of a server s _t at time τ is given as follows:

$$ E_t(\tau) = PC_t(\hbox{tr}_t(\tau)) = \beta_t(|C_t(\tau)|) \cdot \alpha_t \cdot \hbox{tr}_t(\tau) + \hbox{min}E_t. $$

(2)

Here, C _t (τ) indicates a set of clients to which a server s _t sends files at time τ.

The power consumption $\hbox{TPC}_t(\tau_1, \tau_2)$ [W] of a server s _t from time τ₁ to time τ₂ is given as follows:

$$ \hbox{TPC}_t(\tau_1, \tau_2) = \int\limits_{\tau_1}^{\tau_2}{E_t(\tau)} d\tau. $$

(3)

4 Selection algorithms of servers

4.1 Transmission rates

At time τ, the maximum transmission rate maxtr _t (τ) of a server s _t depends on the degradation factor d _t (τ) of the server s _t , i.e. the number of requesting clients to which the server s _t concurrently transmits files at time τ. Each time a new request is issued by a client c _s and a current request for a client c _s is terminated at time $\tau, C_t(\tau) = C_t(\tau)\cup \{c_s\}$ and $C_t(\tau) = C_t(\tau) - \{c_s\},$ respectively. Here, the maximum transmission rate maxtr _t (τ) of a server s _t at time τ is calculated as $\gamma^{1-|C_t(\tau)|} \cdot\hbox{Maxtr}_t.$ Here, $0 < \gamma \leq 1.$ In the fair allocation algorithm, the transmission rate tr _ts (τ) for each client c _s in C _t (τ) is the same, i.e. $\hbox{tr}_{ts}(\tau) =\hbox{maxtr}_t(\tau)/|C_t(\tau)|.$ The server s _t can transmit messages to a client c _s at rate $\hbox{maxtr}_t(\tau)/|C_t(\tau)|.$ However, the maximum receipt rate Maxrr _s of the client c _s might be smaller than $\hbox{maxtr}_t(\tau)/|C_t(\tau)|.$ Here, the rate $(\hbox{maxtr}_t(\tau)/|C_t(\tau)|-\hbox{Maxrr}_s)$ is not used. In order to efficiently use the total transmission rate maxtr _t (τ), the higher receipt rate a client c _s has, the higher transmission rate a server s _t allocates to c _s .

In another proportional way, the transmission rate tr _ts (τ) for each client c _s is proportional to the maximum receipt rate Maxrr _s . Here, $\hbox{tr}_{ts}(\tau)=\hbox{Maxtr}_t \cdot \hbox{Maxrr}_s/(\sum_{c_{s} \in C_{t}(\tau)}\hbox{Maxrr}_{s}).$ Here, a slower client has to receive messages at slower rate.

In this paper, we consider a novel algorithm where each client c _s is guaranteed to be allocated with $\hbox{maxtr}_t(\tau)/|C_t(\tau)|$ if needed. However, a client c _s may not use the transmission rate $u_{ts}(\tau) = \hbox{maxtr}_t(\tau)/(|C_t(\tau)|-\hbox{Maxrr}_s)$ if the allocated transmission rate $\hbox{maxtr}_t(\tau)/|C_t(\tau)|$ is larger than the maximum receipt rate Maxrr _s . The unused transmission rate u _ts (τ) is allocated to other clients which need the higher rate. The transmission rate tr _ts (τ) is decided so that the following conditions hold:

$$ \begin{aligned} & \hbox{minimize}\left(\hbox{Maxtr}_t - \sum\nolimits_{c_s \in C_t(\tau)}\hbox{tr}_{ts}(\tau)\right).\\ & \hbox{minimize}\sum\limits_{c_s \in C_t(\tau)}(\hbox{Maxrr}_s - \hbox{tr}_{ts}(\tau)). \end{aligned} $$

In the papers (Enokido et al. 2009, 2010b), the following algorithm to allocate each client c _s with the transmission rate tr _ts (τ) is discussed for each time τ:

• 1. $V = 0; \; R = 0; \; TS = \hbox{maxtr}_t/|C_t(\tau)|;$

• 2. For each client $c_s, \hbox{tr}_t(\tau) = TS$ and R = R + (TS − Maxrr _s ) if $\hbox{Maxrr}_s \leq TS.$ Otherwise, $\hbox{tr}_t(\tau) = \hbox{Maxrr}_s$ and V = V + (Maxrr _s  − TS).

• 3. For each client $c_s, \hbox{tr}_{ts}(\tau)=\hbox{tr}_{ts}(\tau)+V \cdot(\hbox{Maxrr}_s-\hbox{tr}_{ts}(\tau))/R$ if $\hbox{tr}_{ts}(\tau)< \hbox{Maxrr}_s.$

Suppose a server s _t is selected by three clients $c_1, c_2, c_3(C_t(\tau) = \{c_1, c_2, c_3\})$ and the maximum transmission rate maxtr _t (τ) of the server s _t is 6 Mbps at time τ as shown in Fig. 4. Suppose Maxrr₁ = 1 Mbps, Maxrr₂ = 2 Mbps, and Maxrr₃ = 4 Mbps. In the basic fair allocation algorithms, each client c _s is allocated with the same transmission rate $\hbox{tr}_{ts}(\tau) = \hbox{maxtr}_t(\tau)/|C_t(\tau)| = 6 / 3= 2$  Mbps as shown in Fig. 4(1). Here, the transmission rate 2 − 1 = 1 Mbps is not used for the client c ₁. In addition, the client c ₃ cannot use the maximum receipt rate Maxrr₃ (= 4 Mbps). In the proportional way, the client $c_1, c_2,$ and c ₃ are allocated with 6/7 = 0.86, 12/7 = 1.71, and 24/7 = 3.43 Mbps, respectively. In the algorithm discussed here, the unused transmission rate of the client c ₁ (= 1 Mbps) can be used for the client c ₃. That is, the clients $c_1, c_2,$ and c ₃ receive files at 1, 2, and 3 Mbps, respectively.

Fig. 4

Transmission rate allocation

4.2 TRB and PCB algorithms

Next, we discuss how a load balancer K selects a file server s _t for a client c _s in the server set S. In the paper (Enokido et al. 2009), two types of server selection algorithms, transmission rate-based (TRB) and power consumption-based (PCB) algorithms to select a server for a client are proposed. In addition, we evaluated the PCB and TRB algorithms (Enokido et al. 2010b) in terms of the total power consumption and the total transmission time compared with the basic round-robin (RR) algorithm [Weighted Least Connection (WLC), http://www.linuxvirtualserver.org/docs/scheduling.html (1998); Weighted Round Robin (WRR), http://www.linuxvirtualserver.org/docs/scheduling.html (1998)]. In the TRB algorithm, a server s _t is selected for a client c _s where the transmission rate tr _ts (τ) of the server s _t to transmit a file f to a client c _s is the largest. On the other hand, in the PCB algorithm, a server s _t is selected for the client c _s where the power consumption is the smallest. Here, |f|/tr _ts (τ) is an estimated transmission time at time τ when a server s _t starts transmitting a file f to a client c _s with a transmission rate tr _ts (τ). The power consumption rate E _ts (τ) of each server s _t at time τ is $\beta_t(|C_t(\tau)|) \cdot \alpha_t \cdot \hbox{tr}_{ts}(\tau)$ as discussed in the preceding section. It is not easy to estimate how much electric power the server s _t consumes to transmit a file f to the client c _s since there might be other clients which receive files. Here, the estimated change of power consumption EE _ts (τ) [W] of a server s _t for transmitting a file f to a client c _s at time τ when the server s _t starts transmitting the file f is $(|f|/\hbox{tr}_{ts}(\tau))\cdot\beta_t(|C_t(\tau)|)\cdot \alpha_t \cdot \hbox{tr}_{ts}(\tau) = |f| \cdot\beta_t(|C_t(\tau)|) \cdot \alpha_t.$ Here, a server s _t whose EE _ts (τ) is minimum is selected for a client c _s .

According to the evaluation results (Enokido et al. 2010b), the total power consumption and the total transmission time can be reduced in the PCB and TRB algorithms compared with the basic RR algorithm. In the PCB algorithm, the total power consumption can be more reduced than the TRB algorithm and the difference of the total transmission time between PCB and TRB is almost neglectable. In reality, the transmission rate between a server s _t and a client c _s is dynamically changed in the network since the transmission rate of a server s _t is dynamically changed based on the number of clients. It is not easy to estimate the transmission rate of the server s _t to a client c _s from the practical point of view. In addition, a server s _t for a client c _s can be selected without considering the transmission rate between the server s _t and the client c _s in the PCB algorithm. Therefore, the PCB algorithm is simpler and more useful than the TRB and RR algorithms.

4.3 Extended power consumption-based (EPCB) algorithm

In this paper, we newly propose an extended power consumption-based (EPCB) algorithm by improving the PCB algorithm. Suppose a server s _t is selected for a client c _s and starts transmitting a file to the client c _s at time τ. In the PCB algorithm, the estimated change of power consumption $EE_{ts}(\tau)= |f| \cdot \beta_t(|C_t(\tau)|) \cdot \alpha_t$ is considered to select a server s _t . This means, only the power consumption for a server s _t to transmit a file f _s to a client c _s at time τ is considered. The server s _t might be transmitting the file f to other clients at time τ when starting transmitting the file f to the client c _s . The power consumption to be consumed by a server s _t to transmit files to other clients has to be considered for obtaining the more correct estimation of the power consumption. Here, l _ts (τ) shows laxity of a file f _s where a server s _t has to transmit the file f to a client c _s from time τ as presented in the preceding section. Here, the estimated change EE _ts (τ) [W] of power consumption of a server s _t for transmitting a file f _s to a client c _s at time τ when the server s _t starts transmitting the file f is defined as follows:

$$ EE_{ts}(\tau) = \Upsigma_{c_s \in C_t(\tau)}l_{ts}(\tau) \cdot \beta_t(|C_t(\tau)|) \cdot \alpha_t. $$

(4)

Here, it is noted l _ts (τ) is |f _s | at time τ when the server s _t starts transmitting a file f _s to a client c _s . A server s _t is selected for a client c _s in the EPCB algorithm by using EE _ts (τ) at time τ as follows:

Let us consider an example of a pair of servers s ₁ and s ₂. The power consumption coefficients α₁ and α₂ to transmit 1 Mbit for one client of servers s ₁ and s ₂ are 0.09 and 0.07, respectively. The server s ₁ is selected by a client c ₁ $(C_1(\tau) = \{c_1\})$ and the server s ₂ is selected by a client $c_2 (C_2(\tau) = \{c_2\})$ at time τ, respectively. Suppose a client c ₃ issues a new request to transmit a file f whose size is one Gbytes to a load balancer K at time τ. Here, a pair of laxity l ₁₁(τ) and l ₂₁(τ) are 0.1 and 0.9 GByte, respectively, at time τ. In the PCB algorithm, a server s _t which has the minimum value of the formula $|f| \cdot\beta_t(|C_t(\tau)|) \cdot \alpha_t$ is selected in the PCB algorithm. Here, sets C ₁(τ) and C ₂(τ) of current clients of servers s ₁ and s ₂ include two clients, $\{c_1, c_3\}$ and $\{c_2, c_3\},$ respectively. Suppose the increasing rates β₁(2) and β₂(2) of the power consumption of the servers s ₁ and s ₂ are 1.2 and 1.1, respectively. Here, $|f|\cdot\beta_1(2)\cdot\alpha_1 = 1 \cdot 1.2 \cdot 0.09 = 0.108.|f|\cdot\beta_2(2)\cdot\alpha_2 = 1 \cdot 1.1 \cdot 0.07 = 0.077.$ Therefore, the server s ₂ is selected for a client c ₃ in the PCB algorithm. On the other hand, a server s _t which has the minimum value of the formula $\Upsigma_{c_s \in C_t(\tau)}l_{st}(\tau)\cdot \beta_t(|C_t(\tau)|) \cdot\alpha_t$ is selected in the EPCB algorithm. Here, $\Upsigma_{c_s \in C_1(\tau)}l_{1s}(\tau)\cdot\beta_1(2) \cdot\alpha_1 = (1 + 0.1) \cdot 1.2 \cdot 0.09 = 0.119.\Upsigma_{c_s \in C_2(\tau)}l_{2s}(\tau)\cdot \beta_2(2) \cdot\alpha_2 = (1 + 0.9) \cdot 1.1 \cdot 0.07 = 0.146.$ Therefore, the server s ₁ is selected for a client c ₃ in the EPCB algorithm.

5 Evaluation

5.1 Evaluation environment

We evaluate the EPCB algorithm in terms of the total amount of power consumption and total transmission time of files compared with the TRB and PCB algorithms through the simulation. In the evaluation, there are five servers $s_1, s_2, s_3, s_4,$ and s ₅ as shown in Table 3, $S = \{s_1,\; s_2,\; s_3,\; s_4,\; s_5\}.$ The power consumption coefficient α _t to transmit one Mbits for one client of each server s _t is randomly selected between 0.02 and 0.11 W/Mb based on the experimental results. The increasing rate of the power consumption β _t (m) for the number m of clients is randomly selected between 1.09 and 1.5. The minimum power consumption rate minE _t of each server s _t is randomly selected between 3 and 4 W. The maximum transmission rate Maxtr _t of each server s _t is randomly selected between 150 and 450 Mbps. Each server s _t has a full replica of a file f. The size |f| of the file f is one giga-byte.

Table 3 Types of servers

Totally 100 clients download the file f from one server s _t in the server set S. The maximum receipt rate Maxrr _s of each client c _s is randomly selected between 1 and 100 Mbps. Each client c _s issues a transfer request of the file f to a load balancer K at time st _s . Here, the starting time st _s of each client c _s is randomly selected between 1 and 3,600 s at the simulation time. Each client c _s issues one file transfer request at time st _s in the simulation. In the simulations of the EPCB, TRB, and PCB algorithms, the starting time st _s of the file transmission to each client c _s is the same.

5.2 Total power consumption

Figure 5 shows the total power consumption rates (W/s) of the servers $s_1, \ldots, s_5$ at each time. Table 4 shows the total power consumptions of the servers in the EPCB, PCB, and TRB algorithms. The total power consumptions of the EPCB, PCB, and TRB algorithms are 204,973, 209,831, and 250,176 W, respectively. In the TBR algorithm, a server s _t is selected for a client c _s , whose transmission rate for the client c _s is the largest. Then, the total amount of power consumption is larger than the EPCB and PCB algorithms. In the EPCB and PCB algorithms, a server s _t is selected for a client c _s , whose power consumption is the smallest to transmit a file f to the client c _s . The total amount of power consumption of the EPCB algorithm is smaller than the PCB algorithm. The total power consumption in the EPCB algorithm is reduced about 2% than the PCB algorithm.

Fig. 5

Total power consumption rate

Table 4 Total amount of power consumption (W)

5.3 Total transmission time

Table 5 shows the total transmission time of the files to the 100 clients in the PCB, TRB, and RR algorithms. The total transmission time are 28,614, 28,594, and 43,744 s in the PCB, TRB, and RR algorithms, respectively. The total transmission time of the TRB algorithm is smaller than the PCB and RR algorithms. However, the difference of the total transmission time between TRB and PCB is neglectable. In the TRB algorithm, a server s _t is selected, which can supply the maximum transmission rate. Therefore, the difference of the transmission time between PCB and TRB is so small as to be neglected in this simulation.

Table 5 Total transmission time (s) of the files

In the EPCB and PCB algorithms, a server s _t is selected for a client c _s without considering the transmission rate between the server s _t and the client c _s . On the other hand, a server s _t is selected for a client c _s based on the estimated transmission rate in the TRB algorithm. From the evaluation results, we consider the total power consumption can be more reduced in the EPCB algorithm than the PCB and TRB algorithms and the difference of the total transmission time between the EPCB, PCB and TRB algorithms is neglectable. In reality, the transmission rate between a server s _t and a client c _s is dynamically changed in the network since the transmission rate of a server s _t is dynamically changed based on the number of clients. It is not easy to estimate the transmission rate of the server s _t to a client c _s from the practical point of view. A server s _t for a client c _s can be selected without considering the transmission rate between the server s _t and the client c _s in the EPCB and PCB algorithms. In addition, The power consumption can be more reduced in the EPCB algorithm than the PCB algorithm. Therefore, the EPCB algorithm is simpler and more useful than the TRB and PCB algorithms.

6 Concluding remarks

In this paper, we proposed the EPCB algorithm to select one file transfer server for a requesting client by improving the PCB algorithm. The PCB algorithm is more useful than the TRB and traditional RR algorithms since the transmission rate is not considered. However, only the power consumption of a server s _t to transmit a file f to a new requesting client c _s is considered to estimate the total power consumption of the server s _t for transmitting the file f. There might be some clients receiving files from the server s _t on receipt of a file transfer request from the client c _s . Therefore, the power consumption of the server to transmit files to other clients has to be considered for estimating the total power consumption of the server s _t . In this paper, we improved the estimation of the power consumption of a server for transmitting a file. We evaluated the EPCB algorithm in terms of the total power consumption and the total transmission time compared with the TRB and PCB algorithms through simulation. According to the evaluation results, the total power consumption can be reduced in the EPCB algorithm compared with the TRB and PCB algorithms. The difference of the total transmission time among the EPCB, PCB and TRB algorithms is almost neglectable. Therefore, the EPCB algorithm is more useful for reducing the total power consumption in the communication-based applications.