An energy-efficient quorum-based locking protocol by omitting meaningless methods on object replicas

Abstract

In current information systems, a huge number of IoT (Internet of Things) devices are interconnected with various kinds of networks like WiFi and 5G networks. A large volume of data is gathered into servers from a huge number of IoT devices and is manipulated to provide application services. Gathered data is encapsulated along with methods to manipulate the data as an object like a database system. In object-based systems, each application is composed of multiple objects. In addition, each object is replicated on multiple physical servers in order to increase availability, reliability, and performance of an application service. On the other hand, replicas of each object is required to be mutually consistent in presence of multiple transactions. Here, a larger amount of electric energy and computation resources are consumed in physical servers than non-replication approaches to serialize conflicting transactions on multiple replicas. Many algorithms to synchronize conflicting transactions are so far proposed like 2PL (Two-Phase Locking) and TO (Timestamp Ordering). However, the electric energy consumption is not considered. In this paper, an EEQBL-OMM (Energy-Efficient Quorum-Based Locking with Omitting Meaningless Method) protocol is newly proposed to reduce not only the average execution time of each transaction but also the total electric energy consumption of servers by omitting the execution of meaningless methods on replicas of each object. Evaluation results show the total electric energy consumption of servers, the average execution time of each transaction, and the number of aborted instances of transactions in the EEQBL-OMM protocol can be on average reduced to 79%, 62%, and 80% of the ECLBQS (Energy Consumption Laxity-Based Quorum Selection) protocol which is proposed in our previous studies in a homogeneous set of servers, respectively. In addition, the evaluation results show the total electric energy consumption of servers, the average execution time of each transaction, and the number of aborted instances of transactions in the EEQBL-OMM protocol can be on average reduced to 73%, 50%, and 67% of the ECLBQS protocol in a heterogeneous set of servers, respectively. The evaluation results also show at most 48% and 51% of the total number of methods can be omitted as meaningless methods in a homogeneous set and heterogeneous set of servers, respectively, in the EEQBL-OMM protocol.

Keywords

Distributed object-based systems locking protocols meaningless methods green computing EEQBL-OMM protocol

1. Introduction

Various types of IoT (Internet of Things) [3,16,21] devices which combine various kinds of hardware components like sensors, actuators, and cameras are developed to sense various situations and respond to the change of state. These IoT devices are embedded into various kinds of equipments like home electric appliances [20] and factory automation equipments [34], and provide the connection to various types of networks like wireless and wired networks. In current information systems, a huge number of IoT devices are interconnected with various kinds of network systems like Ethernet, WiFi, and 5G networks to provide various types of distributed application services like factory automation [34], home management [20], and vehicle network services [2,30]. IoT devices sense various kinds of events like sounds and air vibrations, and send the sensor data to servers in a system to store and manipulate the data. Hence, a large volume of data is gathered into servers from a huge number of IoT devices and is manipulated to provide application services. High performance, scalable, and fault-tolerant computing systems like cloud [4,22,35] and fog [23,32] computing systems with IoT networks are required to design and implement these distributed application services. Data gathered from IoT devices is encapsulated along with methods to manipulate the data as an object [27]. An object [27] is an unit of computation resource like a database system. Data in an object can be manipulated by using only methods encapsulated in the object. Objects are distributed on multiple physical servers in a system. In object-based systems, each application is composed of multiple objects distributed in multiple physical servers.

A transaction [1] is an atomic sequence of methods to manipulate target objects. Each transaction created on a client issues methods supported by target objects to use a provided application service. A composition ${op}_{1} \circ {op}_{2} (o)$ means that a state obtained by performing a method ${op}_{1}$ after another method ${op}_{2}$ on an object o. Here, a method ${op}_{1}$ conflicts with another method ${op}_{2}$ iff (if and only if) ${op}_{1} \circ {op}_{2} (o) \neq {op}_{2} \circ {op}_{1} (o)$ . Otherwise, a pair of methods ${op}_{1}$ and ${op}_{2}$ is compatible with each other. For example, a write method conflicts with a read method on an object. On the other hand, a pair of read methods are compatible on an object. Conflicting methods issued by multiple transactions might be concurrently performed on each object and have to be serialized to keep all the objects mutually consistent. The 2PL (Two-Phase Locking) protocol [1] and the TO (Timestamp Ordering) scheduler [1] are widely used to serialize multiple conflicting transactions. In the 2PL protocol and TO scheduler, multiple conflicting transactions are serialized based on principles “first comer is a winner” and “timestamp order”, respectively. In our previous studies, the RO (Role Ordering) scheduler [12] is proposed to serialize multiple conflicting transaction based on the significant dominant relation among roles [24]. The LIF (Legal Information Flow) scheduler [8] and the PM (Purpose-Marking) protocol [13] are proposed to not only serialize multiple conflicting transactions but also prevent illegal information flow.

In order to increase availability, reliability, and performance of an application service, replication approaches [26] are widely used in object-based systems. Each object which constructs an application service is replicated on multiple physical servers. Here, replicas of each object have to be serialized to keep replicas of each object mutually consistent. The 2PL protocol with “read-one-write-all” scheme [26] and QBL (Quorum-Based Locking) protocol [17] are widely used to serialize multiple conflicting transactions in the replication approach. Replicas of each object can be mutually consistent by using the 2PL and QBL protocols in the replication approach. However, a larger amount of electric energy is consumed in servers than non-replication approaches since each method issued to an object is performed on multiple replicas allocated to multiple physical servers. In order to design and implement a reliable, available and high performance application service in object-based systems, the energy-efficient concurrency control mechanism is required to not only serialize multiple conflicting transactions on replicas of each object in an application but also reduce the total electric energy consumption of servers to perform methods issued by the transactions as discussed in Green computing [11,28,31].

In our previous studies, the ECLBQS (Energy Consumption Laxity-Based Quorum Selection) protocol [9] is proposed to select a quorum of replicas for each method issued by a transaction so that the total electric energy consumption of servers to perform read and write methods can be reduced in the QBL protocol. However, every method issued by each transaction is surely performed on every replica in a quorum selected by the ECLBQS protocol. As a result, the more number of transactions are issued in an application, the larger amount of electric energy is consumed in the ECLBQS protocol compared with non-replication approaches. In this paper, meaningless methods which are not required to be performed on each replica of an object are defined based on the semantics of methods supported by each object and the precedent relation among methods issued by transactions. Then, an EEQBL-OMM (Energy-Efficient Quorum-Based Locking with Omitting Meaningless Method) protocol is newly proposed to furthermore reduce the total electric energy consumption of servers than the ECLBQS protocol by omitting the execution of meaningless methods on replicas of each object. The EEQBL-OMM protocol is evaluated in terms of the total electric energy consumption of servers to perform methods issued by transactions, the average execution time of each transaction, the number of aborted transactions, and the ratio of meaningless methods to the total number of methods issued by transactions compared with the ECLBQS protocol in sets of homogeneous and heterogeneous servers, respectively. The evaluation results show the total electric energy consumption of servers, the average execution time of each transaction, and the number of aborted instances of transactions in the EEQBL-OMM protocol can be on average reduced to 79%, 62%, and 80% of the ECLBQS protocol, respectively, in a homogeneous set of servers. The total electric energy consumption of servers, the average execution time of each transaction, and the number of aborted instances of transactions in the EEQBL-OMM protocol can be reduced to at most 83%, 72%, and 93% of the ECLBQS protocol, respectively, in a homogeneous set of servers. In addition, the total electric energy consumption of servers, the average execution time of each transaction, and the number of aborted instances of transactions in the EEQBL-OMM protocol can be on average reduced to 73%, 50%, and 67% of the ECLBQS protocol, respectively, in a heterogeneous set of servers. The total electric energy consumption of servers, the average execution time of each transaction, and the number of aborted instances of transactions in the EEQBL-OMM protocol can be reduced to at most 81%, 66%, and 88% of the ECLBQS protocol, respectively, in a heterogeneous set of servers. In addition, the evaluation results show at most 48% and 51% of the total number of methods issued by transaction can be omitted as meaningless methods in a homogeneous set and heterogeneous set of servers, respectively, in the EEQBL-OMM protocol while every method is surely performed in the ECLBQS protocol.

In Section 2, we show related studies on concurrency control mechanisms and energy-efficient information systems. In Section 3, we discuss the system model of this paper. In Section 4, we define the meaningless methods and propose the EEQBL-OMM protocol. In Section 5, we evaluate the EEQBL-OMM protocol compared with the ECLBQS protocol. Table 1 shows a list of acronyms used in this paper.

Table 1
List of acronyms

Acronyms Definitions

AAT Average number of Aborted instances for each Transaction

AET Average Execution Time

ATPEE Average Total Processing Electric Energy

ECLBQS Energy Consumption Laxity-Based Quorum Selection

EEQBL-OMM Energy-Efficient Quorum-Based Locking with Omitting Meaningless Method

LIF Legal Information Flow

OBO Object-Based Ordered

OG Object-based Group

PEP Processing Electric Power

PCS Power Consumption model for a Storage server

PM Purpose Marking

QBL Quorum-Based Locking

QOL Quorum-based Object Locking

RO Role Ordering

TEE Total Electric Energy

TNM Total Number of Methods

TNMM Total Number of Meaningless Methods

TO Timestamp Ordering

TPEE Total Processing Electric Energy

2PL Two-Phase Locking

Λ Average Ratio of the Total Number of Meaningless Methods

Acronyms	Definitions
AAT	Average number of Aborted instances for each Transaction
AET	Average Execution Time
ATPEE	Average Total Processing Electric Energy
ECLBQS	Energy Consumption Laxity-Based Quorum Selection
EEQBL-OMM	Energy-Efficient Quorum-Based Locking with Omitting Meaningless Method
LIF	Legal Information Flow
OBO	Object-Based Ordered
OG	Object-based Group
PEP	Processing Electric Power
PCS	Power Consumption model for a Storage server
PM	Purpose Marking
QBL	Quorum-Based Locking
QOL	Quorum-based Object Locking
RO	Role Ordering
TEE	Total Electric Energy
TNM	Total Number of Methods
TNMM	Total Number of Meaningless Methods
TO	Timestamp Ordering
TPEE	Total Processing Electric Energy
2PL	Two-Phase Locking
Λ	Average Ratio of the Total Number of Meaningless Methods

2. Related works

There are various kinds of approaches to serializing multiple conflicting transactions. In our previous studies, the OBO (Object-Based Ordered) relation [10] among request and response messages is defined based on the conflicting and precedent relations among methods performed on each object. Then, the OG (Object-based Group) protocol [10] is proposed based on the OBO relation to not only serialize multiple conflicting methods on each object but also order only messages which are required to be ordered at application level. The role-based access control model [24] is widely used in object-based systems. A role is a job function in an enterprise and is defined to be a set of access rights in a system. The significant dominant relation among roles [12] is defined based on the significancy of objects, methods, and access rights in our previous studies. Then, the RO (Role Ordering) scheduler [12] is proposed to serialize multiple conflicting transactions based on the significancy of roles granted to subjects which issue the transactions. The LIF (Legal Information Flow) relation [8] among roles is defined based on the precedent relation among roles. Then, the LIF scheduler [8] is proposed to not only prevent illegal information flow but also serialize conflicting transactions based on the significancy and information flow relation among roles. The purpose concept [13,33] is proposed based on the role concept [12,24]. A purpose of a transaction is a subfamily of roles granted to the subject who created the transaction. The PM (Purpose Marking) protocol [13] is proposed based on the purpose concept to not only serialize multiple conflicting transaction in significancy of purposes but also prevent illegal information flow. In object-based systems, each object might be replicated on multiple physical servers in order to increase the availability, reliability, and performance of an application service. However, in these serialization approaches, the replication of objects is not considered.

Physical servers might stop by fault [1,18,19,26]. If a physical server stops by fault, methods which are being performed on objects in the physical server also stop. Then, transactions which issue the methods to the objects in the faulty physical server also have to abort. As a result, an application service stops due to the fault of the physical server. Types of replication approaches [26] are widely used to increase availability and reliability of an application service. In the replication approach, each object which constructs an application service is replicated on multiple physical servers. Availability and reliability of an application service can increase by using the replication approach. On the other hand, throughput of an application service might decrease since conflicting methods issued by multiple transactions have to be serialized to keep replicas of each object mutually consistent. The 2PL (Two-Phase Locking) protocol [1] is widely used in object-based systems to serialize multiple conflicting transaction where each object is replicated on multiple physical servers. In the 2PL protocol, each transaction has to lock replicas of each target object before manipulating the object. Hence, only a transaction which locks replicas of an target object earlier than the other transactions can manipulate the object. The other transactions have to wait for releasing locks on the replicas of the object. Therefore, in the 2PL protocol, multiple conflicting transactions are serialized based on a mechanism that only the first comer is a winner and the others are losers. In the 2PL protocol, the “read-one-write-all” scheme [1,26] is widely used to serialize multiple conflicting transactions where each object is replicated on multiple physical servers. In the read-one-write-all scheme, one replica of an object and all the replicas of an object are locked for each of read and write methods, respectively, before manipulating the object. However, the read-one-write-all scheme is not efficient for the write dominant application services since each transaction has to lock every replica for each target object before issuing a write method. As a result, throughput of an application service decreases since the overhead to lock replicas of each object increases in write dominant application services. The QBL (Quorum-Based Locking) protocol [17] is proposed as an object replication approach to not only serialize multiple conflicting transactions but also reduce the overhead to perform write methods on replicas of each object. In the QBL protocol, each transaction locks subsets of replicas for read and write methods, respectively, before manipulating an object. Subsets of replicas locked for read and write methods are referred to as $read quorum$ (r- $quorum$ ) and $write quorum$ (w- $quorum$ ), respectively. Let ${nQ}^{r}$ and ${nQ}^{w}$ be quorum numbers for read and write methods, respectively, i.e. the number of replicas to be locked for read and write methods. In the QBL protocol, the condition “ ${nQ}^{r} + {nQ}^{w} > N$ ” has to be satisfied where N is the total number of replicas of an object. The more number of write methods are issued and concurrently performed on an object, the fewer write quorum number ${nQ}^{w}$ can be taken in the QBL protocol. As a result, the overhead to lock replicas of each object and perform write methods can be reduced in the QBL protocol than the 2PL protocol with read-one-write-all scheme. In our previous studies, the QOL (Quorum-based Object Locking) protocol [29] is proposed to furthermore reduce the overhead to lock the replicas of each object than the QBL protocol by considering abstract methods supported by each object. In the TO (Timestamp Ordering) scheduler [1], multiple conflicting transactions can be serialized without a locking mechanism. In TO scheduler, every transaction is given a timestamp when the transaction is created in a system. Hence, transactions can be totally ordered by using their timestamps. In the TO scheduler, multiple conflicting transactions are serialized based on the timestamp order of the transactions. However, in these protocols and schedulers, every method issued by each transaction is surely performed on every target replicas. As a result, the more number of transactions are issued in a system and concurrently performed on replicas of each object, a larger electric energy is consumed in servers than non-replication approaches. Hence, an energy-efficient concurrency control mechanism where each object is replicated on multiple servers has to be designed and implemented to not only serialize multiple conflicting transactions but also reduce the total electric energy consumption of servers to perform methods on replicas of each object as discussed in Green computing [11,28,31].

The electric power consumed in a server depends on not only hardware devices equipped in the server but also types of application processes performed on the server. In our previous studies, the electric power of a physical server is measured to perform computation [5–7,16], communication [14], storage [25], and general [15] types of application processes. Then, the PCS (Power Consumption model for a Storage server) model [25] to concurrently perform storage and computation types of application processes on a server is proposed. Based on the PCS model, the ECLBQS (Energy Consumption Laxity-Based Quorum Selection) protocol [9] is proposed to reduce the total electric energy consumption of physical servers in the QBL protocol. In the ECLBQS protocol, each time a transaction selects a quorum for each method, the transaction selects members of the quorum so that the total electric energy consumption of servers to perform the method is the minimum. As a result, the total electric energy consumption of servers can be more reduced in the ECLBQS protocol than the QBL protocol. However, every method issued by each transaction is surely performed on every replica in each quorum selected by the ECLBQS protocol. Hence, we newly define meaningless methods which are not required to be performed on each replica based on the semantics and the precedent relation among methods supported by each object in this paper. In addition, we newly propose the EEQBL-OMM (Energy-Efficient Quorum-Based Locking with Omitting Meaningless Method) protocol to furthermore reduce the total electric energy consumption of servers than the ECLBQS protocol by omitting the execution of meaningless methods on replicas of each object.

3. System model

3.1. Object-based systems

An object-based system is composed of a set S of multiple physical servers $s_{1}, \dots, s_{n}$ ( $n ⩾ 1$ ) and clients interconnected in reliable networks. In this paper, a term server means a physical server. An application service is composed of a set O of objects $o_{1}, \dots, o_{m}$ ( $m ⩾ 1$ ) [27]. An object $o_{h}$ is an unit of computation resource like a database system. Each object $o_{h}$ is an encapsulation of data and methods to manipulate the data in the object $o_{h}$ . Methods supported by each object $o_{h}$ are classified into read (r) and $write$ (w) methods. Write methods are furthermore classified in to partial write ( $w^{p}$ ) and full write ( $w^{f}$ ) methods, i.e. $w = {w^{f}, w^{p}}$ . In this paper, we assume data in an object is fully read by a read method. A part of data in an object $o_{h}$ is written by a partial write method. A whole data in an object is fully written by a full write method. For example, suppose a file object F supports create, drop, modify, and read methods. Here, a pair of create and drop methods are full write methods. A modify method is a partial write method since only some field of a record is changed. A notation $op (o_{h})$ shows a state of an object $o_{h}$ obtained by performing a method $op$ ( $op = {w^{f}, w^{p}, r}$ ). Let ${op}_{1} \circ {op}_{2} (o_{h})$ be a state of an object $o_{h}$ by performing a method ${op}_{1}$ before another method ${op}_{2}$ . A method ${op}_{1}$ conflicts with another method ${op}_{2}$ on an object $o_{h}$ iff (if and only if) ${op}_{1} \circ {op}_{2} (o_{h}) \neq {op}_{2} \circ {op}_{1} (o_{h})$ . Otherwise, a pair of methods ${op}_{1}$ and ${op}_{2}$ on an object $o_{h}$ are $compatible$ with each other, i.e. ${op}_{1} \circ {op}_{2} (o_{h}) = {op}_{2} \circ {op}_{1} (o_{h})$ for every state of an object $o_{h}$ . In this paper, the conflicting relations among methods is assumed to hold as shown in Table 2 and the conflicting relation among methods is symmetric. For example, a pair of read methods on a file object F are compatible. On the other hand, a read method conflicts with create, drop, modify methods, respectively, on the file object F.

Table 2
Conflicting relation among methods

read (r) full write ( $w^{f}$ ) partial write ( $w^{p}$ )

read (r) ◯ × ×

full write ( $w^{f}$ ) × × ×

partial write ( $w^{p}$ ) × × ×

	read (r)	full write ( $w^{f}$ )	partial write ( $w^{p}$ )
read (r)	◯	×	×
full write ( $w^{f}$ )	×	×	×
partial write ( $w^{p}$ )	×	×	×

◯: compatible. ×: conflict.

Each object $o_{h}$ is replicated on multiple servers to increase availability, reliability, and performance of an application service. A notation $R (o_{h})$ shows a set of replicas $o_{h}^{1}, \dots, o_{h}^{l}$ ( $1 ⩽ l ⩽ n$ ) [26] of an object $o_{h}$ . Let $nR (o_{h})$ be the total number of replicas of an object $o_{h}$ , i.e. $nR (o_{h}) = | R (o_{h}) |$ . Replicas of each object $o_{h}$ are distributed on multiple servers in a set S of physical servers where each pair of replicas $o_{h}^{i}$ and $o_{h}^{j}$ are on different physical servers. A notation $S_{h}$ denotes a subset of physical servers which hold a replica of an object $o_{h}$ ( $S_{h} \subseteq S$ ). For example, a set S of multiple physical servers is composed of three servers $s_{1}$ , $s_{2}$ , and $s_{3}$ as shown in Fig. 1. An application service is composed of two objects $o_{1}$ and $o_{2}$ , i.e. $O = {o_{1}, o_{2}}$ . Each object $o_{h}$ is replicated on two servers in a set S of servers, i.e. $nR (o_{h}) = 2$ ( $h = 1, 2$ ). For the object $o_{1}$ , $R (o_{1}) = {o_{1}^{1}, o_{1}^{2}}$ and $S_{1} = {s_{1}, s_{2}}$ . $R (o_{2}) = {o_{2}^{1}, o_{2}^{2}}$ and $S_{2} = {s_{2}, s_{3}}$ for the object $o_{2}$ .

Fig. 1.

Replication of objects.

3.2. Transactions and Quorum-Based Locking (QBL) protocol

A transaction [1] is an atomic sequence of methods. A transaction $T_{i}$ is created on a client ${cl}_{i}$ and issues read (r) and write (w) methods to manipulate replicas of objects. Let T be a set ${T_{1}, \dots, T_{k}}$ ( $k ⩾ 1$ ) of transactions created in a system. Multiple conflicting methods issued by multiple transactions are required be serializable [1,18,26] to keep replicas of every object mutually consistent. A notation $sch$ denotes a schedule of transactions in a set T of transactions. A transaction $T_{i}$ precedes another transaction $T_{j}$ ( $T_{i} \to_{sch} T_{j}$ ) in a schedule $sch$ iff (if and only if) a method ${op}_{i}$ issued by the transaction $T_{i}$ is performed before another method ${op}_{j}$ issued by the transaction $T_{j}$ and the method ${op}_{i}$ conflicts with the method ${op}_{j}$ . A schedule $sch$ is serializable iff the precedent relation $\to_{sch}$ is acyclic [1].

The QBL (Quorum-Based Locking) protocol [17,29] is proposed to serialize multiple conflicting transactions in order to keep replicas of every object in a system mutually consistent. In this paper, we assume each object is replicated on multiple servers and multiple conflicting transactions are serialized based on the QBL protocol. Let $lm (op)$ be a lock mode of a method $op$ ( $= {r, w}$ ). A lock mode $lm ({op}_{1})$ conflicts with another lock mode $lm ({op}_{2})$ iff a method ${op}_{1}$ conflicts with another method ${op}_{2}$ on an object $o_{h}$ . Otherwise, a pair of lock modes $lm ({op}_{1})$ and $lm ({op}_{2})$ are compatible, i.e. a pair of methods ${op}_{1}$ and ${op}_{2}$ are compatible on an object $o_{h}$ . For example, a lock mode $lm (drop)$ conflicts with a lock mode $lm (read)$ on a file object F since a drop method conflicts with a read method on the file object F. On the other hand, a pair of lock modes $lm (read)$ are compatible since a pair of read methods are compatible on the file object F. A notation $Q_{h}^{op}$ ( $\subseteq R (o_{h})$ ) shows a subset of replicas of an object $o_{h}$ to be locked by a method $op$ . A subset $Q_{h}^{op}$ of replicas is referred to as a quorum [17,29] of a method $op$ on an object $o_{h}$ . Let ${nQ}_{h}^{op}$ be the quorum number of a method $op$ on a object $o_{h}$ , i.e. the number of replicas in a set $Q_{h}^{op}$ ( ${nQ}_{h}^{op} = | Q_{h}^{op} |$ ).

Quorum conditions

Every quorum has to satisfy the following conditions:

$Q_{h}^{w} \subseteq R (o_{h})$ , $Q_{h}^{r} \subseteq R (o_{h})$ , and $Q_{h}^{r} \cup Q_{h}^{w} = R (o_{h})$ .

${nQ}_{h}^{r} + {nQ}_{h}^{w} > nR (o_{h})$ , i.e. $Q_{h}^{r} \cap Q_{h}^{w} \neq ϕ$ .

${nQ}_{h}^{w} > nR (o_{h}) / 2$ .

Suppose there are three replicas

o_{h}^{1}

o_{h}^{2}

, and

o_{h}^{3}

of an object

o_{h}

. If a pair of replicas

o_{h}^{1}

and

o_{h}^{2}

are updated but the replica

o_{h}^{3}

is not updated, a pair of replicas

o_{h}^{1}

and

o_{h}^{2}

are newer than the replica

o_{h}^{3}

. If the quorum conditions are satisfy, at least one newest replica

o_{h}^{q}

of an object

o_{h}

is surely included in every quorum. Each transaction

T_{i}

locks replicas of an object

o_{h}

before manipulating the replicas with a method

op

by the following QBL protocol [17,29]:

Quorum-Based Locking (QBL) Protocol

A transaction $T_{i}$ selects ${nQ}_{h}^{op}$ replicas in a set $R (o_{h})$ of replicas of an object $o_{h}$ according to the quorum conditions. A quorum $Q_{h}^{op}$ for a method $op$ is composed of the selected ${nQ}_{h}^{op}$ replicas.

If the transaction $T_{i}$ could lock every replica in a quorum $Q_{h}^{op}$ by a lock mode $lm (op)$ , the transaction $T_{i}$ issues the method $op$ and the replicas in the quorum $Q_{h}^{op}$ are manipulated by the method $op$ .

When the transaction $T_{i}$ commits or aborts, the locks on the replicas in the quorum $Q_{h}^{op}$ are released. Once the transaction $T_{i}$ releases locks on the replicas in the quorum $Q_{h}^{op}$ , the transaction $T_{i}$ does not lock replicas on any object until the transaction $T_{i}$ commits or aborts.

In the QBL protocol, each replica $o_{h}^{q}$ has a version number $v_{h}^{q}$ . Suppose a transaction $T_{i}$ is created on a client ${cl}_{i}$ to read an object $o_{h}$ . The transaction $T_{i}$ selects ${nQ}_{h}^{r}$ replicas in a set $R (o_{h})$ according to the quorum conditions, i.e. the transaction $T_{i}$ selects a read (r-) quorum $Q_{h}^{r}$ for a read method. If the transaction could lock every replica in the r-quorum $Q_{h}^{r}$ by a lock mode $lm (r)$ , the transaction $T_{i}$ reads data d in a replica $o_{h}^{q}$ whose version number $v_{h}^{q}$ is the maximum in the r-quorum $Q_{h}^{r}$ . Suppose a transaction $T_{i}$ is created on a client ${cl}_{i}$ to write data in an object $o_{h}$ . The transaction $T_{i}$ selects ${nQ}_{h}^{w}$ replicas in a set $R (o_{h})$ , i.e. the transaction selects $write$ (w-) quorum $Q_{h}^{w}$ for a write method. If the transaction $T_{i}$ could lock every replica in the w-quorum $Q_{h}^{w}$ by a lock mode $lm (w)$ , the transaction $T_{i}$ writes data d in a replica $o_{h}^{q}$ whose version number $v_{h}^{q}$ is maximum in the w-quorum $Q_{h}^{w}$ . In addition, the version number $v_{h}^{q}$ of the replica $o_{h}^{q}$ is incremented by one. The updated data d and version number $v_{h}^{q}$ of the replica $o_{h}^{q}$ are sent to every other replica in the w-quorum $Q_{h}^{w}$ . On receipt of the updated data d and version number $v_{h}^{q}$ , each replica in the w-quorum $Q_{h}^{w}$ replaces their data and version number with the newest values.

3.3. Data access model of read and write methods

In object-based systems, each transaction can manipulate objects only through methods supported by the objects. Methods which are being performed on replicas of objects are current at time τ. Let ${RP}_{t} (τ)$ and ${WP}_{t} (τ)$ be sets of current read (r) and write (w) methods performed on a server $s_{t}$ at time τ, respectively. A notation $P_{t} (τ)$ denotes a set of current read and write methods on a server $s_{t}$ at time τ, i.e. $P_{t} (τ) = {RP}_{t} (τ) \cup {WP}_{t} (τ)$ . Let $r_{ti} (o_{h}^{q})$ be a read method issued by a transaction $T_{i}$ to read data in a replica $o_{h}^{q}$ stored in a server $s_{t}$ . Let $w_{ti} (o_{h}^{q})$ be a write method issued by a transaction $T_{i}$ to write data in a replica $o_{h}^{q}$ on a server $s_{t}$ . At time τ, a current read method $r_{ti} (o_{h}^{q})$ in a set ${RP}_{t} (τ)$ reads data in a replica $o_{h}^{q}$ at rate ${RR}_{ti} (τ)$ [Bytes/sec (B/sec)]. A current write method $w_{ti} (o_{h}^{q})$ in a set ${WP}_{t} (τ)$ writes data in a replica $o_{h}^{q}$ at rate ${WR}_{ti} (τ)$ [B/sec]. Let $max R R_{t}$ and $max W R_{t}$ be the maximum read and write rates [B/sec] supported by a server $s_{t}$ , respectively. At time τ, the read rate ${RR}_{ti} (τ)$ [B/sec] ( $⩽ max R R_{t}$ ) and write rate ${WR}_{ti} (τ)$ [B/sec] ( $⩽ max W R_{t}$ ) for each read and write method performed on a server $s_{t}$ are given as Eq. (1), respectively $\begin{matrix} (1) & \begin{matrix} {RR}_{ti} (τ) = {dr}_{t} (τ) \cdot max R R_{t}, \\ {WR}_{ti} (τ) = {dw}_{t} (τ) \cdot max W R_{t} . \end{matrix} \end{matrix}$ Here, ${dr}_{t} (τ)$ and ${dw}_{t} (τ)$ are degradation ratios of the read rate ${RR}_{ti} (τ)$ and write rate ${WR}_{ti} (τ)$ , respectively. The degradation ratio ${dr}_{t} (τ)$ is $1 / (| {RP}_{t} (τ) | + {rw}_{t} \cdot | {WP}_{t} (τ) |)$ where $0 ⩽ {rw}_{t} ⩽ 1$ . The degradation ratio ${dw}_{t} (τ)$ is $1 / ({wr}_{t} \cdot | {RP}_{t} (τ) | + | {WP}_{t} (τ) |)$ where $0 ⩽ {wr}_{t} ⩽ 1$ . The read rate ${RR}_{ti} (τ)$ and write rate ${WR}_{ti} (τ)$ for each read and write method depend on the number of current read and write methods being performed on a server $s_{t}$ at time τ.

The read laxity ${lr}_{ti} (τ)$ [Bytes (B)] and write laxity ${lw}_{ti} (τ)$ [B] of methods $r_{ti} (o_{h}^{q})$ and $w_{ti} (o_{h}^{q})$ show how much amount of data are to be read and written in a replica $o_{h}^{q}$ by the methods $r_{ti} (o_{h}^{q})$ and $w_{ti} (o_{h}^{q})$ , respectively, at time τ. Suppose that methods $r_{ti} (o_{h}^{q})$ and $w_{ti} (o_{h}^{q})$ start on a server $s_{t}$ at time ${st}_{ti}$ , respectively. At time ${st}_{ti}$ , the read laxity ${lr}_{ti} (τ)$ is ${rb}_{h}^{q}$ [B] where ${rb}_{h}^{q}$ is the size of data in a replica $o_{h}^{q}$ to be read by a read method $r_{ti} (o_{h}^{q})$ . The write laxity ${lw}_{ti} (τ)$ is ${wb}_{h}^{q}$ [B] where ${wb}_{h}^{q}$ is the size of data to be written in a replica $o_{h}^{q}$ by a write method $w_{ti} (o_{h}^{q})$ . The read laxity ${lr}_{ti} (τ)$ [B] and write laxity ${lw}_{ti} (τ)$ [B] at time τ are given as Eq. (2), respectively $\begin{matrix} (2) & \begin{matrix} {lr}_{ti} (τ) = {rb}_{h}^{q} - Σ_{τ = {st}_{ti}}^{τ} {RR}_{ti} (τ), \\ {lw}_{ti} (τ) = {wb}_{h}^{q} - Σ_{τ = {st}_{ti}}^{τ} {WR}_{ti} (τ) . \end{matrix} \end{matrix}$

3.4. Electric power consumption model of a server

The PCS (Power Consumption model for a Storage server) model [25] to concurrently perform storage and computation processes is proposed in our previous studies. A notation $E_{t} (τ)$ shows the electric power [W] consumed by a server $s_{t}$ at time τ. Let $max E_{t}$ and $min E_{t}$ be the maximum and minimum electric power [W] consumed by a server $s_{t}$ , respectively. In this paper, we assume only read and write methods are performed on a server $s_{t}$ to manipulate replicas of objects allocated to the server $s_{t}$ . According to the PCS model, the electric power $E_{t} (τ)$ [W] of a server $s_{t}$ at time τ to concurrently perform multiple read and write methods is given as Eq. (3). $\begin{matrix} (3) & E_{t} (τ) = \{\begin{matrix} min E_{t} & if | {WP}_{t} (τ) | = | {RP}_{t} (τ) | = 0, \\ {RE}_{t} & if | {WP}_{t} (τ) | = 0 and | {RP}_{t} (τ) | ⩾ 1, \\ {WRE}_{t} (α) & if | {WP}_{t} (τ) | ⩾ 1 and | {RP}_{t} (τ) | ⩾ 1, \\ {WE}_{t} & if | {WP}_{t} (τ) | ⩾ 1 and | {RP}_{t} (τ) | = 0 . \end{matrix} \end{matrix}$

The electric power consumed in a server $s_{t}$ is the minimum electric power $min E_{t}$ [W] if no method is performed on the server $s_{t}$ , i.e. the electric power where the server $s_{t}$ is in the idle state. The server $s_{t}$ consumes the electric power ${RE}_{t}$ [W] if only read methods are performed on the server $s_{t}$ . The server $s_{t}$ consumes the electric power ${WE}_{t}$ [W] if only write methods are performed on the server $s_{t}$ . The server $s_{t}$ consumes the electric power ${WRE}_{t} (α) [W] = α \cdot {RE}_{t} + (1 - α) \cdot {WE}_{t}$ [W] where $α = | {RP}_{t} (τ) | / (| {RP}_{t} (τ) | + | {WP}_{t} (τ) |)$ if both at least one read method and at least one write method are concurrently performed in the server $s_{t}$ . Here, $min E_{t} ⩽ {RE}_{t} ⩽ {WRE}_{t} (α) ⩽ {WE}_{t} ⩽ max E_{t}$ .

In this paper, time is modeled to be a discrete sequence of time units [tu]. The total electric energy (TEE) ${TEE}_{t} (τ_{1}, τ_{2})$ [J] consumed in a server $s_{t}$ between time $τ_{1}$ and $τ_{2}$ is $Σ_{τ = τ 1}^{τ_{2}} E_{t} (τ)$ . The processing electric power (PEP) ${PEP}_{t} (τ)$ [W] consumed in a server $s_{t}$ at time τ is $E_{t} (τ)$ - $min E_{t}$ . The total processing electric energy (TPEE) ${TPEE}_{t} (τ_{1}, τ_{2})$ [J] consumed in a server $s_{t}$ between time $τ_{1}$ and $τ_{2}$ is given as ${TPEE}_{t} (τ_{1}, τ_{2}) = Σ_{τ = τ 1}^{τ_{2}} {PEP}_{t} (τ)$ . The total processing electric energy laxity ${tpeel}_{t} (τ)$ [J] [9] of a server $s_{t}$ shows how much electric energy the server $s_{t}$ has to consume to perform every current read and write methods on the server $s_{t}$ at time τ. In our previous studies, the ${TPECL}_{t} (τ)$ procedure [9] is proposed to calculate the total processing electric energy laxity ${tpeel}_{t} (τ)$ [J] of a server $s_{t}$ at time $τ$ .

4. Energy-efficient protocol

4.1. Quorum selection with the ECLBQS protocol

In our previous studies, the ECLBQS (Energy Consumption Laxity-Based Quorum Selection) protocol [9] is proposed to select a quorum for each method issued by a transaction so that the total electric energy consumption of a set $S$ of servers $s_{1}, \dots, s_{n}$ ( $n ⩾$ 1) to perform read and write methods can be reduced. Suppose a transaction $T_{i}$ issues a method $op$ ( $op$ = { $r$ , $w$ }) to manipulate replicas of an target object $o_{h}$ at time $τ$ . The transaction $T_{i}$ selects replicas to be members of a quorum for the method $op$ so that the total electric energy consumption of a set $S$ of servers to perform the method $op$ is the minimum in the ECLBQS protocol. In the ECLBQS protocol, each transaction $T_{i}$ selects a subset $S_{h}^{op}$ ( $\subseteq S_{h}$ ) of ${nQ}_{h}^{op}$ servers which hold replicas of target objects, whose total processing electric energy laxity is the minimum by the ECLBQS protocol [9] as shown in Algorithm 1.

Algorithm 1

ECLBQS protocol

4.2. EEQBL-OMM protocol

In this paper, we newly define meaningless methods which are not required to be performed on each replica of an object based on the semantics of methods supported by each object and the precedent relation among methods issued by transactions. Then, an EEQBL-OMM (Energy-Efficient Quorum-Based Locking with Omitting Meaningless Method) protocol is newly proposed to furthermore reduce the total electric energy consumption of a set $S$ of servers than the ECLBQS protocol by omitting the execution of meaningless methods on replicas of each object.

Definition.
A method ${op}_{1}$ precedes another method ${op}_{2}$ in a schedule $sch$ ( ${op}_{1} \to_{sch} {op}_{2}$ ) iff (if and only if) one of the following conditions holds:
The methods ${op}_{1}$ is issued before another method ${op}_{2}$ by a same transaction $T_{i}$ .

The method ${op}_{1}$ issued by a transaction $T_{i}$ conflicts with the method ${op}_{2}$ issued by a transaction $T_{j}$ and $T_{i} \to_{sch} T_{j}$ .

${op}_{1} \to_{sch} {op}_{3} \to_{sch} {op}_{2}$ for some method ${op}_{3}$ .

A notation ${sch}_{h}^{q}$ shows a local schedule of methods which are performed on a replica $o_{h}^{q}$ of an object $o_{h}$ in a schedule $sch$ in a set T of transactions.
Definition.
A method ${op}_{1}$ locally precedes another method ${op}_{2}$ in a local schedule ${sch}_{h}^{q}$ ( ${op}_{1} \to_{{sch}_{h}^{q}} {op}_{2}$ ) iff ${op}_{1} \to_{sch} {op}_{2}$ .

Suppose a partial write method $w_{ti}^{p} (o_{h}^{q})$ issued by a transaction $T_{i}$ locally precedes a full write method $w_{tj}^{f} (o_{h}^{q})$ issued by another transaction $T_{j}$ in a local schedule ${sch}_{h}^{q}$ ( $w_{ti}^{p} (o_{h}^{q}) \to_{{sch}_{h}^{q}} w_{tj}^{f} (o_{h}^{q})$ ) on a replica $o_{h}^{q}$ of an object $o_{h}$ . Here, it is not necessary to perform the partial write method $w_{ti}^{p} (o_{h}^{q})$ on the replica $o_{h}^{q}$ of the object $o_{h}$ if the full write method $w_{tj}^{f} (o_{h}^{q})$ is surely performed on the replica $o_{h}^{q}$ just after the partial write method $w_{ti}^{p} (o_{h}^{q})$ , i.e. the full write method $w_{tj}^{f} (o_{h}^{q})$ issued by the transaction $T_{j}$ can absorb the partial write method $w_{ti}^{p} (o_{h}^{q})$ issued by the transaction $T_{i}$ on the replica $o_{h}^{q}$ .
Absorption of Write Methods.
A full write method ${op}_{1}$ absorbs another partial or full write method ${op}_{2}$ in a local subschedule ${sch}_{h}^{q}$ on a replica $o_{h}^{q}$ of an object $o_{h}$ iff one of the following conditions is hold:
${op}_{2} \to_{{sch}_{h}^{q}} {op}_{1}$ and there is no read method ${op}^{'}$ such that ${op}_{2} \to_{{sch}_{h}^{q}} {op}^{'} \to_{{sch}_{h}^{q}} {op}_{1}$ .

${op}_{1}$ absorbs ${op}^{″}$ and ${op}^{″}$ absorbs ${op}_{2}$ for some method ${op}^{″}$ .

Absorption of Read Methods.
A read method ${op}_{1}$ absorbs another read method ${op}_{2}$ in a local subschedule ${sch}_{h}^{q}$ on a replica $o_{h}^{q}$ of an object $o_{h}$ iff one of the following conditions is hold:
${op}_{1} \to_{{sch}_{h}^{q}} {op}_{2}$ and there is no write method ${op}^{'}$ such that ${op}_{1} \to_{{sch}_{h}^{q}} {op}^{'} \to_{{sch}_{h}^{q}} {op}_{2}$ .

${op}_{1}$ absorbs ${op}^{″}$ and ${op}^{″}$ absorbs ${op}_{2}$ for some method ${op}^{″}$ .

Meaningless Methods.
A method $op$ is meaningless iff the method $op$ is absorbed by another method ${op}^{'}$ in the local subschedule ${sch}_{h}^{q}$ on a replica $o_{h}^{q}$ of an object $o_{h}$ .

In the EEQBL-OMM protocol, the total electric energy consumption of a set $S$ of servers can be more reduced than the ECLBQS protocol by omitting the execution of meaningless methods on replicas of each object. Suppose a set $S$ of servers is composed of five servers $s_{1}, \dots, s_{5}$ , i.e. $S$ ={ $s_{1}$ , $s_{2}$ , $s_{3}$ , $s_{4}$ , $s_{5}$ }. An object $o_{h}$ is replicated on the five servers, i.e. $R (o_{h}) = {o_{h}^{1}, o_{h}^{2}, o_{h}^{3}, o_{h}^{4}, o_{h}^{5}}$ and $nR (o_{h}) = 5$ . Initially, the version numbers $v_{h}^{1}$ , $v_{h}^{2}$ , $v_{h}^{3}$ , $v_{h}^{4}$ , and $v_{h}^{5}$ of replicas $o_{h}^{1}$ , $o_{h}^{2}$ , $o_{h}^{3}$ , $o_{h}^{4}$ , and $o_{h}^{5}$ are 2, 1, 2, 2, and 1, respectively, as shown in Fig. 2 and Fig. 3. The quorum numbers ${nQ}_{h}^{w}$ and ${nQ}_{h}^{r}$ for the object $o_{h}$ are three according to the quorum conditions. A notation $T_{i}$ . $Q_{h}^{op}$ shows a quorum to perform a method $op$ issued by a transaction $T_{i}$ on an object $o_{h}$ . Let $T_{i}$ . $S_{h}^{op}$ be a subset of servers which hold replicas in a quorum $T_{i}$ . $Q_{h}^{op}$ .

Suppose a transaction $T_{i}$ selects three replicas $o_{h}^{1}$ , $o_{h}^{2}$ , and $o_{h}^{3}$ as a r-quorum $T_{i}$ . $Q_{h}^{r_{ti} (o_{h})}$ (= { $o_{h}^{1}$ , $o_{h}^{2}$ , $o_{h}^{3}$ }) by using the ECLBQS protocol [9] to perform a read method $r_{ti} (o_{h})$ on an object $o_{h}$ . Three replicas $o_{h}^{1}$ , $o_{h}^{2}$ , and $o_{h}^{3}$ are locked by the transaction $T_{i}$ with a lock mode $lm (r)$ . Then, the read method $r_{ti} (o_{h})$ is issued to the r-quorum $T_{i}$ . $Q_{h}^{r_{ti} (o_{h})}$ . The read method $r_{3 i} (o_{h}^{3})$ is performed on a replica $o_{h}^{3}$ since the version number $v_{h}^{3}$ (= 2) is the maximum in the $r$ -quorum $T_{i}$ . $Q_{h}^{r_{ti} (o_{h})}$ as shown in Fig. 2. Another transaction $T_{j}$ locks three replicas $o_{h}^{3}$ , $o_{h}^{4}$ , and $o_{h}^{5}$ with a lock mode $lm (r)$ and a read method $r_{tj} (o_{h})$ is issued to a $r$ -quorum $T_{j}$ . $Q_{h}^{r_{tj} (o_{h})}$ (= { $o_{h}^{3}$ , $o_{h}^{4}$ , $o_{h}^{5}$ }). Suppose the read method $r_{3 j} (o_{h}^{3})$ is performed on the replica $o_{h}^{3}$ since the version number $v_{h}^{3}$ (= 2) is the maximum in the $r$ -quorum $T_{j}$ . $Q_{h}^{r_{tj} (o_{h})}$ , i.e. a pair of read methods $r_{3 i} (o_{h}^{3})$ and $r_{3 j} (o_{h}^{3})$ are concurrently performed on a replica $o_{h}^{3}$ and $r_{3 i} (o_{h}^{3})$ $\to_{{sch}_{h}^{3}} r_{3 j} (o_{h}^{3})$ . Here, the read method $r_{3 j} (o_{h}^{3})$ issued by the transaction $T_{j}$ is a meaningless method since the read method $r_{3 i} (o_{h}^{3})$ issued by the transaction $T_{i}$ is being performed on the replica $o_{h}^{3}$ and $r_{3 i} (o_{h}^{3})$ absorbs the read method $r_{3 j} (o_{h}^{3})$ . Hence, the read method $r_{3 j} (o_{h}^{3})$ is not performed on a replica $o_{h}^{3}$ and a result obtained by performing the read method $r_{3 i} (o_{h}^{3})$ is sent to a pair of transactions $T_{i}$ and $T_{j}$ . This means that the meaningless read method $r_{3 j} (o_{h}^{3})$ is omitted on the replica $o_{h}^{3}$ .

Fig. 2.
A meaningless read method.

Suppose three replicas $o_{h}^{1}$ , $o_{h}^{2}$ , and $o_{1}^{2}$ are locked by a transaction $T_{i}$ with lock mode $lm (w)$ and a partial write methods $w_{ti}^{p} (o_{h})$ is issued to a $w$ -quorum $T_{i}$ . $Q_{h}^{w_{ti}^{p} (o_{h})}$ (= { $o_{h}^{1}$ , $o_{h}^{2}$ , $o_{h}^{3}$ }) as shown in Fig. 3. The partial write method $w_{1 i}^{p} (o_{h}^{1})$ is performed on the replica $o_{h}^{1}$ since the version number $v_{h}^{1}$ (= 2) of the replica $o_{h}^{1}$ is the maximum in the $w$ -quorum $T_{i}$ . $Q_{h}^{w_{ti}^{p} (o_{h})}$ . Then, the version number $v_{h}^{1}$ is incremented by one, i.e. $v_{h}^{1} = 3$ . The updated data and version number $v_{h}^{1}$ (= 3) are sent to a pair of replicas $o_{h}^{2}$ and $o_{h}^{3}$ . In the QBL protocol, data and version numbers of a pair of replicas $o_{h}^{2}$ and $o_{h}^{3}$ are replaced with the newest values as soon as the replicas $o_{h}^{2}$ and $o_{h}^{3}$ receive the updated data and version number, respectively. In the EEQBL-OMM protocol, a pair of version numbers $v_{h}^{2}$ and $v_{h}^{3}$ of the replicas $o_{h}^{2}$ and $o_{h}^{3}$ are replaced with the newest value but data of the replicas $o_{h}^{2}$ and $o_{g}^{3}$ are not replaced with the newest values until the next method is performed on the replicas $o_{h}^{2}$ and $o_{h}^{3}$ , respectively. This means that a pair of partial write methods $w_{2 i}^{p} (o_{h}^{2})$ and $w_{3 i}^{p} (o_{h}^{3})$ to replace data of the replicas $o_{h}^{2}$ and $o_{h}^{3}$ are delayed until the next method is performed on the replicas $o_{h}^{2}$ and $o_{h}^{3}$ , respectively. Suppose three replicas $o_{h}^{3}$ , $o_{h}^{4}$ , and $o_{h}^{5}$ are locked by a transaction $T_{j}$ with lock mode $lm (w)$ and a full write methods $w_{tj}^{f} (o_{H})$ is issued to a $w$ -quorum $T_{j}$ . $Q_{h}^{w_{tj}^{f} (o_{h})}$ (= { $o_{h}^{3}$ , $o_{h}^{4}$ , $o_{h}^{5}$ }) after the transaction $T_{i}$ commits. Suppose the full write method $w_{3 j}^{f} (o_{h}^{3})$ issued by the transaction $T_{j}$ is performed on the replica $o_{h}^{3}$ since the version number $v_{h}^{3}$ (= 3) is the maximum in the $w$ -quorum $T_{j}$ . $Q_{h}^{w_{tj}^{f} (o_{h})}$ . Here, the partial write method $w_{3 i}^{p} (o_{h}^{3})$ issued by the transaction $T_{i}$ is a meaningless method since the full write method $w_{3 j}^{f} (o_{h}^{3})$ absorbs the partial write method $w_{3 i}^{p} (o_{h}^{3})$ on the replica $o_{h}^{3}$ . Hence, the full write method $w_{3 j}^{f} (o_{h}^{3})$ can be performed on the replica $o_{h}^{3}$ without performing the partial write method $w_{3 i}^{p} (o_{h}^{3})$ and the version number of the replica $o_{h}^{3}$ is incremented by one, i.e. $o_{h}^{3} = 4$ . This means that the meaningless write method $w_{3 i}^{p} (o_{h}^{3})$ is omitted on a replica $o_{h}^{3}$ .

Fig. 3.
A meaningless write method.

Suppose three replicas $o_{h}^{3}$ , $o_{h}^{4}$ , and $o_{h}^{5}$ are locked by a transaction $T_{u}$ with lock mode $lm (r)$ and a read method $r_{tu} (o_{h})$ is issued to a $r$ -quorum $T_{u}$ . $Q_{h}^{r_{tu} (o_{h})}$ (= { $o_{h}^{3}$ , $o_{h}^{4}$ , $o_{h}^{5}$ }) after the transaction $T_{i}$ commits as shown in Fig. 3. The transaction $T_{u}$ reads data in the replica $o_{h}^{3}$ since the version number $v_{h}^{3}$ (= 3) is the maximum in the $r$ -quorum $T_{u}$ . $Q_{h}^{r_{tu} (o_{h})}$ . Here, the partial write method $w_{3 i}^{p} (o_{h}^{3})$ issued by a transaction $T_{i}$ has to be performed before the read method $r_{3 u} (o_{h}^{3})$ is performed on the replica $o_{h}^{3}$ since the read method $r_{3 u} (o_{h}^{3})$ has to read data written by the partial write method $w_{3 i}^{p} (o_{h}^{3})$ issued by the transaction $T_{i}$ .

A notation $o_{h}^{q}$ . $CR$ shows a read method $r_{ti} (o_{h}^{q})$ issued by a transaction $T_{i}$ , which is being performed on a replica $o_{h}^{q}$ in a server $s_{t}$ . Let $o_{h}^{q}$ . $DW$ be a write method $w_{ti} (o_{h}^{q})$ issued by a transaction $T_{i}$ to replace data of a replica $o_{h}^{q}$ in a server $s_{t}$ with the updated data $d_{h}$ , which is waiting for the next method $op$ to be performed on the replica $o_{h}^{q}$ . Suppose a transaction $T_{i}$ issues a method $op$ to a quorum $Q_{h}^{op}$ for manipulating an object $o_{h}$ . The method $op (o_{h})$ is performed on a replica $o_{h}^{q}$ whose version number is the maximum in the quorum $Q_{h}^{op}$ . In the EEQBL-OMM protocol, the method $op$ is performed on the replica $o_{h}^{q}$ whose version number is the maximum in the quorum $Q_{h}^{op}$ by the EEQBL-OMM_Perform_Method procedure as shown in Algorithm 2.

Algorithm 2
EEQBL-OMM_Perform_Method Procedure

Each time a replica $o_{h}^{q^{'}}$ in a write quorum $Q_{h}^{w}$ receives the newest version number $v_{h}^{q}$ and updated data $d_{h}$ from another replica $o_{h}^{q}$ , the replica $o_{h}^{q^{'}}$ manipulates the version number $v_{h}^{q}$ and updated data $d_{h}$ by the EEQBL-OMM_Replace procedure as shown in Algorithm 3.

Algorithm 3
EEQBL-OMM_Replace Procedure

In the EEQBL-OMM protocol, meaningless methods are omitted on replicas of each object by using the EEQBL-OMM_Perform_Method and EEQBL-OMM_Replace procedures. As a result, the total electric energy consumption of a set $S$ of servers can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol.
5. Evaluation results

5.1. Evaluation environment

We evaluate the EEQBL-OMM protocol in terms of the total electric energy consumption of servers in a system, the average execution time of transactions, and the average number of aborted transactions compared with the ECLBQS protocol. In this evaluation, we consider a homogeneous set $S^{HO}$ and a heterogeneous set $S^{HE}$ of servers. The homogeneous set $S^{HO}$ of servers is composed of twenty servers $s_{1}, \dots, s_{20}$ ( $n = 20$ ) and every server $s_{t}$ ( $t = 1, \dots, 20$ ) follows the same data access model and power consumption model as shown in Table 3. The parameters of the data access model and power consumption model of every server $s_{t}$ in the set $S^{HO}$ are given based on the experimentations [25]. The maximum read rate $max R R_{t}$ [B/sec] and write rate $max W R_{t}$ [B/sec] supported by every server $s_{t}$ are 80 and 45 [MB/sec], respectively. The parameters ${rw}_{t}$ and ${wr}_{t}$ in the read and write degradation ratios ${dr}_{t} (τ)$ and ${dw}_{t} (τ)$ of every server $s_{t}$ are 0.5, respectively. The minimum electric power $min E_{t}$ [W] of every server $s_{t}$ is 39 [W]. The electric power ${WE}_{t}$ of every server $s_{t}$ where only write methods are performed is 53 [W]. The electric power ${RE}_{t}$ of every server $s_{t}$ where only read methods are performed is 43 [W]. An example of the server $s_{t}$ is the Orion server used in the experimentation [25]. The Orion server is equipped with an Intel core-i7-4790 CPU, eight mega-bytes memory, and two tera-bytes hard disk drive.

Table 3
A homogeneous set $S^{HO}$ of servers ( $t = 1, \dots, 20$ )

server $s_{t}$ $max R R_{t}$ $max W R_{t}$ ${rw}_{t}$ ${wr}_{t}$ $min E_{t}$ ${WE}_{t}$ ${RE}_{t}$

$s_{t}$ 80 [MB/sec] 45 [MB/sec] 0.5 0.5 39 [W] 53 [W] 43 [W]

server $s_{t}$	$max R R_{t}$	$max W R_{t}$	${rw}_{t}$	${wr}_{t}$	$min E_{t}$	${WE}_{t}$	${RE}_{t}$
$s_{t}$	80 [MB/sec]	45 [MB/sec]	0.5	0.5	39 [W]	53 [W]	43 [W]

The heterogeneous set $S^{HE}$ of servers is composed of twenty servers $s_{1}, \dots, s_{20}$ ( $n = 20$ ). There are three types of servers ${Type}_{1} = {s_{1}, \dots, s_{7}}$ , ${Type}_{2} = {s_{8}, \dots, s_{14}}$ , ${Type}_{3} = {s_{15}, \dots, s_{20}}$ as shown in Table 4. The parameter of data access model and power consumption model of every server of each type is the same for each server type. In ${Type}_{1}$ , every parameter of seven servers $s_{1}, \dots, s_{7}$ on data access model and power consumption model is the same as a server $s_{t}$ ( $t = 1, \dots, 20$ ) in the homogeneous set $S^{HO}$ servers. In ${Type}_{2}$ , the maximum read rate $max R R_{t}$ [B/sec] and write rate $max W R_{t}$ [B/sec] supported by seven servers $s_{8}, \dots, s_{14}$ are 120 and 67 [MB/sec], respectively. The parameters ${rw}_{t}$ and ${wr}_{t}$ in the read and write degradation ratios ${dr}_{t} (τ)$ and ${dw}_{t} (τ)$ of every server $s_{t}$ in ${Type}_{2}$ are 0.5, respectively. The minimum electric power $min E_{t}$ [W] of every server $s_{t}$ in ${Type}_{2}$ is 59 [W]. The electric powers ${WE}_{t}$ and ${RE}_{t}$ of every server $s_{t}$ in ${Type}_{2}$ are 80 [W] 64 [W], respectively. In ${Type}_{3}$ , $max R R_{t} = 80$ [MB/sec] and $max W R_{t} = 45$ [MB/sec] for every server $s_{t}$ ( $t = 15, \dots, 20$ ). The parameters ${rw}_{t}$ and ${wr}_{t}$ in the read and write degradation ratios ${dr}_{t} (τ)$ and ${dw}_{t} (τ)$ of every server $s_{t}$ in ${Type}_{3}$ are 0.5, respectively. The minimum electric power $min E_{t}$ [W] of every server $s_{t}$ in ${Type}_{3}$ is 45 [W]. The electric powers ${WE}_{t}$ and ${RE}_{t}$ in ${Type}_{3}$ are 60 [W] and 49 [W], respectively. An example of the ${Type}_{1}$ server is the Orion server used in the homogeneous set $S^{HO}$ of servers. The parameters of ${Type}_{2}$ and ${Type}_{3}$ servers are defined based on the parameters of the Orion server [25].

Table 4

A heterogeneous set $S^{HE}$ of servers ( $t = 1, \dots, 20$ )

Type	server $s_{t}$	$max R R_{t}$	$max W R_{t}$	${rw}_{t}$	${wr}_{t}$	$min E_{t}$	${WE}_{t}$	${RE}_{t}$
${Type}_{1}$	$s_{1}, \dots, s_{7}$	80 [MB/sec]	45 [MB/sec]	0.5	0.5	39 [W]	53 [W]	43 [W]
${Type}_{2}$	$s_{8}, \dots, s_{14}$	120 [MB/sec]	67 [MB/sec]	0.5	0.5	59 [W]	80 [W]	64 [W]
${Type}_{3}$	$s_{15}, \dots, s_{20}$	136 [MB/sec]	76 [MB/sec]	0.5	0.5	45 [W]	60 [W]	49 [W]

A set $O$ of object is composed of sixty objects $o_{1}, \dots, o_{60}$ ( $m = 60$ ) as shown in Table 5, i.e. $O = {o_{1}, \dots, o_{60}}$ . Each object $o_{h}$ supports partial write ( $w^{p}$ ), full write ( $w^{f}$ ), and read ( $r$ ) methods. The size of data in each object $o_{h}$ is randomly selected between 10 and 200 [MB]. The total number of replicas for every object is five, i.e. $R (o_{h}) = {o_{h}^{1}, \dots, o_{h}^{5}}$ and $nR (o_{h}) = 5$ ( $1 ⩽ h ⩽ 60$ ). Replicas of each object are randomly distributed on twenty servers in the homogeneous set $S^{HO}$ and heterogeneous set $S^{HE}$ of servers, respectively. The quorum numbers ${nQ}_{h}^{w}$ and ${nQ}_{h}^{r}$ on every object $o_{h}$ are three. The total number $tn$ of transactions $T_{1}, \dots, T_{tn}$ ( $0 ⩽ tn ⩽ 1, 000$ ) are issues to manipulate objects. Each transaction issues three methods randomly selected from one-hundred eighty methods on the sixty objects. The total amount of data of an object $o_{h}$ is fully read and written by each read ( $r$ ) and full write ( $w^{f}$ ) methods, respectively. On the other hand, a half size of data of an object $o_{h}$ is written by each partial write ( $w^{p}$ ) method. The starting time of each transaction $T_{i}$ is randomly selected in a unit of one second between 1 and 360 [sec].

Table 5

A set $O$ of objects ( $h = 1, \dots, 60$ ) and a set $R (o_{h})$ of replicas ( $l = 1, \dots, 5$ )

Object	Size of data	Supported methods	$R (o_{h})$	$nR (o_{h})$	${nQ}_{h}^{w}$	${nQ}_{h}^{r}$
$o_{h}$	10 ∼ 200 [MB]	$w^{p}$ , $w^{f}$ , $r$	$o_{h}^{1}, \dots, o_{h}^{5}$	5	3	3

5.2. Total processing electric energy consumption

The EEQBL-OMM protocol is evaluated in terms of the average total processing electric energy consumption [J] of the homogeneous set $S^{HO}$ and heterogeneous set $S^{HE}$ of servers to perform the total number $tn$ ( $0 ⩽ tn ⩽ 1, 000$ ) of transactions compared with the ECLBQS protocol. The total processing electric energy consumption [J] of the homogeneous set $S^{HO}$ and heterogeneous set $S^{HE}$ of servers is measured ten times for each number $tn$ of transactions. The average total processing electric energy ATPEE consumption [J] is the average value of ten times measurement of the total processing electric energy consumption.

Figure 4 shows the average total processing electric energy ATPEE consumption [KJ] of the homogeneous set $S^{HO}$ of servers to perform the number $tn$ of transactions in the EEQBL-OMM and ECLBQS protocols. The average total processing electric energy ATPEE consumption of the homogeneous set $S^{HO}$ of servers increases as the number $tn$ of transactions increases in the EEQBL-OMM and ECLBQS protocols. For $0 < tn ⩽ 1, 000$ , the average total processing electric energy ATPEE consumption of the homogeneous set $S^{HO}$ of servers can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol. In the EEQBL-OMM protocol, meaningless methods are omitted on replicas of each object while every method issued by each transaction are surly performed on every target replicas of each object in the ECLBQS protocol. As a result, the average total processing electric energy ATPEE consumption [KJ] of the homogeneous set $S^{HO}$ of servers can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol. For example, for $tn = 1$ ,000, the average total processing electric energy ATPEE consumption [KJ] of the homogeneous set $S^{HO}$ of servers in the EEQBL-OMM and ECLBQS protocols are 242 and 1479 [KJ], respectively. This means the average total processing electric energy ATPEE consumption [KJ] of the homogeneous set $S^{HO}$ of servers in the EEQBL-OMM protocol can be reduced to at most 83% of the ECLBQS protocol. The average total processing electric energy ATPEE consumption [KJ] of the homogeneous set $S^{HO}$ of servers in the EEQBL-OMM protocol can be on average reduced to 79% of the ECLBQS protocol for $0 < tn ⩽ 1, 000$ .

Fig. 4.

Average total processing electric energy ATPEE consumption [KJ] in the homogeneous set $S^{H O}$ of servers.

Figure 5 shows the average total processing electric energy ATPEE consumption [KJ] of the heterogeneous set $S^{HE}$ of servers to perform the number $tn$ of transactions in the EEQBL-OMM and ECLBQS protocols. The average total processing electric energy ATPEE consumption of the heterogeneous set $S^{HE}$ of servers increases as the number $tn$ of transactions increases in the EEQBL-OMM and ECLBQS protocols. For $0 < tn ⩽ 1, 000$ , the average total processing electric energy ATPEE consumption of the heterogeneous set $S^{HE}$ of servers can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol since meaningless methods are omitted in the EEQBL-OMM protocol. For example, for $tn = 900$ , the average total processing electric energy ATPEE consumption [KJ] of the heterogeneous set $S^{HE}$ of servers in the EEQBL-OMM and ECLBQS protocols are 73 and 394 [KJ], respectively. This means the average total processing electric energy ATPEE consumption [KJ] of the heterogeneous set $S^{HE}$ of servers in the EEQBL-OMM protocol can be reduced to at most 81% of the ECLBQS protocol. The average total processing electric energy ATPEE consumption [KJ] of the heterogeneous set $S^{HE}$ of servers in the EEQBL-OMM protocol can be on average reduced to 73% of the ECLBQS protocol for $0 < tn ⩽ 1, 000$ .

Fig. 5.

Average total processing electric energy ATPEE consumption [KJ] in the heterogeneous set $S^{H E}$ of servers.

5.3. Average execution time of transactions

The EEQBL-OMM protocol is evaluated in terms of the average execution time [sec] of transactions in the homogeneous set $S^{HO}$ and heterogeneous set $S^{HE}$ of servers, respectively, to perform the total number $tn$ ( $0 ⩽ tn ⩽ 1, 000$ ) of transactions compared with the ECLBQS protocol. Suppose a transaction $T_{i}$ starts at time ${st}_{i}$ and commits at time ${et}_{i}$ . The execution time ${ET}_{i}$ [sec] of the transaction $T_{i}$ where the transaction $T_{i}$ commits is ${et}_{i}$ - ${st}_{i}$ [sec]. The execution time ${ET}_{i}$ for each transaction $T_{i}$ is measured ten times for each total number $tn$ of transactions ( $0 ⩽ tn ⩽ 1, 000$ ). Let ${ET}_{i}^{β}$ be the execution time ${ET}_{i}$ obtained in $β$ -th simulation. The average execution time AET [sec] of transactions for each total number $tn$ of transactions is $\sum_{β = 1}^{10} \sum_{i = 1}^{tn} {ET}_{i}^{β} / (tn \cdot 10)$ .

Figure 6 shows the average execution time AET [sec] of transactions in the homogeneous set $S^{HO}$ of servers to perform the number $tn$ of transactions in the EEQBL-OMM and ECLBQS protocols. In the EEQBL-OMM and ECLBQS protocols, the average execution time AET of transactions increases as the total number $tn$ of transactions increases since more number of transactions are concurrently performed. For $0 < tn ⩽ 1, 000$ , the average execution time AET of transactions can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol. In the EEQBL-OMM protocol, meaningless methods are omitted on replicas of each object while every method issued by each transaction are surly performed on every target replicas of each object in the ECLBQS protocol. As a result, the average execution time AET of transactions can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol since each transaction can commit without waiting for performing meaningless methods on target replicas of each object in the EEQBL-OMM protocol. For example, for $tn = 700$ , the average execution time AET [sec] of transactions in the homogeneous set $S^{HO}$ of servers in the EEQBL-OMM and ECLBQS protocols are 5.3 and 19.4 [sec], respectively. This means the average execution time AET [sec] of transactions in the homogeneous set $S^{HO}$ of servers in the EEQBL-OMM protocol can be reduced to at most 72% of the ECLBQS protocol. The average execution time AET [sec] of transactions in the homogeneous set $S^{HO}$ of servers in the EEQBL-OMM protocol can be on average reduced to 62% of the ECLBQS protocol for $0 < tn ⩽ 1, 000$ .

Fig. 6.

Average execution time AET [sec] of transactions in the homogeneous set $S^{H O}$ of servers.

Figure 7 shows the average execution time AET [sec] of transactions in the heterogeneous set $S^{HE}$ of servers to perform the number $tn$ of transactions in the EEQBL-OMM and ECLBQS protocols. In the EEQBL-OMM and ECLBQS protocols, the average execution time AET of transactions increases as the total number $tn$ of transactions increases since more number of transactions are concurrently performed. For $0 < tn ⩽ 1, 000$ , the average execution time AET of transactions can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol. The average execution time AET of transactions in the heterogeneous set $S^{HE}$ of servers can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol since each transaction can commit without waiting for performing meaningless methods on target replicas of each object in the EEQBL-OMM protocol. For example, for $tn = 900$ , the average execution time AET [sec] of transactions in the heterogeneous set $S^{HE}$ of servers in the EEQBL-OMM and ECLBQS protocols are 3.6 and 10.7 [sec], respectively. This means the average execution time AET [sec] of each transaction in the heterogeneous set $S^{HE}$ of servers in the EEQBL-OMM protocol can be reduced to at most 66% of the ECLBQS protocol. The average execution time AET [sec] of transactions in the heterogeneous set $S^{HE}$ of servers in the EEQBL-OMM protocol can be on average reduced to 50% of the ECLBQS protocol for $0 < tn ⩽ 1, 000$ .

Fig. 7.

Average execution time AET [sec] of transactions in the heterogeneous set $S^{H E}$ of servers.

5.4. Average number of aborted transaction

The EEQBL-OMM protocol is evaluated in terms of the average number of aborted instances of transactions in the homogeneous set $S^{HO}$ and heterogeneous set $S^{HE}$ of servers to perform the total number $tn$ ( $0 ⩽ tn ⩽ 1, 000$ ) of transactions compared with the ECLBQS protocol. A transaction $T_{i}$ aborts if the transaction $T_{i}$ could not lock every replica in an $r$ -quorum $Q_{h}^{r}$ or $w$ -quorum $Q_{h}^{w}$ before manipulating target objects. In this evaluation, a transaction $T_{i}$ is restarted after $δ$ time units [sec] if the transaction $T_{i}$ aborts. Every transaction $T_{i}$ is restarted until the transaction $T_{i}$ commits. The time units $δ$ [sec] is randomly selected between twenty and thirty seconds ( $20 ⩽ δ ⩽ 30$ ) in this evaluation. Each execution of a transaction is referred to as a transaction instance. We measure how many number of transaction instances are aborted until each transaction commits. Let ${AT}_{i}$ be the number of aborted instances of a transaction $T_{i}$ . The number ${AT}_{i}$ of aborted instances for each transaction $T_{i}$ is measured ten times for each total number $tn$ of transactions ( $0 ⩽ tn ⩽ 1, 000$ ). Let ${AT}_{i}^{β}$ be the number ${AT}_{i}$ of aborted instances of transactions obtained in $β$ -th simulation. The average number AAT of aborted instances of each transaction for each total number $tn$ of transactions is $\sum_{β = 1}^{10} \sum_{i = 1}^{tn} {AT}_{i}^{β} / (tn \cdot 10)$ .

Figure 8 shows the average number AAT of aborted instances for each transaction in the homogeneous set $S^{HO}$ of servers to perform the total number $tn$ of transactions in the EEQBL-OMM and ECLBQS protocols. The more number of transactions are concurrently performed in a system, the more number of transactions cannot lock replicas. As a result, the average number AAT of aborted instances of transactions increases in the EEQBL-OMM and ECLBQS protocols as the total number $tn$ of transactions increases. For $0 < tn ⩽ 1, 000$ , the average number AAT of aborted instances of each transaction can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol. The average execution time of each transaction can be reduced in the EEQBL-OMM protocol than the ECLBQS protocol since each transaction can commit without waiting for performing meaningless methods on target replicas of each object in the EEQBL-OMM protocol. As a result, the average number AAT of aborted instances of transactions in the homogeneous set $S^{HO}$ of servers can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol since the number of transactions to be concurrently performed can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol. For example, for $tn = 700$ , the average number AAT of aborted instances of transactions in the homogeneous set $S^{HO}$ of servers in the EEQBL-OMM and ECLBQS protocols are 5.5 and 82.5, respectively. This means the average number AAT of aborted instances of transactions in the homogeneous set $S^{HO}$ of servers in the EEQBL-OMM protocol can be reduced to at most 93% of the ECLBQS protocol. The average number AAT of aborted instances of transactions in the homogeneous set $S^{HO}$ of servers in the EEQBL-OMM protocol can be on average reduced to 80% of the ECLBQS protocol for $0 < tn ⩽ 1, 000$ .

Fig. 8.

Average number AAT of aborted instances for each transaction in the homogeneous set $S^{H O}$ of servers.

Figure 9 shows the average number AAT of aborted instances for each transaction in the heterogeneous set $S^{HE}$ of servers to perform the total number $tn$ of transactions in the EEQBL-OMM and ECLBQS protocols. The average number AAT of aborted instances of transactions increases in the EEQBL-OMM and ECLBQS protocols as the total number $tn$ of transactions increases. For $0 < tn ⩽ 1, 000$ , the average number AAT of aborted instances of each transaction can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol. The average number AAT of aborted instances of transactions in the heterogeneous set $S^{HE}$ of servers can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol since the number of transactions to be concurrently performed can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol by omitting meaningless methods on target replicas of each object. For example, for $tn = 900$ , the average number AAT of aborted instances of transactions in the heterogeneous set $S^{HE}$ of servers in the EEQBL-OMM and ECLBQS protocols are 4.5 and 40.8, respectively. This means the average number AAT of aborted instances of transactions in the heterogeneous set $S^{HE}$ of servers in the EEQBL-OMM protocol can be reduced to at most 88% of the ECLBQS protocol. The average number AAT of aborted instances of transactions in the heterogeneous set $S^{HE}$ of servers in the EEQBL-OMM protocol can be on average reduced to 67% of the ECLBQS protocol for $0 < tn ⩽ 1, 000$ .

Fig. 9.

Average number AAT of aborted instances for each transaction in the heterogeneous set $S^{H E}$ of servers.

5.5. Ratio of meaningless methods

We measure how many meaningless methods are omitted in the EEQBL-OMM protocol in the homogeneous set $S^{H O}$ and heterogeneous set $S^{H E}$ of servers to perform the total number $t n$ ( $0 ⩽ t n ⩽ 1, 000$ ) of transactions compared with the ECLBQS protocol. Let TNM be the total number of methods issued by the total number $t n$ of transactions until every transaction commits. Let TNMM be the total number of meaningless methods which are omitted on each replica while the total number TNM of methods are issued. Let $λ$ be the ratio of the total number TNMM of meaningless methods to the total number TNM of methods, i.e. $λ = TNMM$ / TNM. $λ = 0$ if there is no meaningless method, i.e. every method is performed on each replica. $λ = 1$ if every method is meaningless, i.e. every method is omitted on each replica. The larger $λ$ is, the more number of meaningless methods are omitted on each replica. The ratio $λ$ is measured ten times for each total number $t n$ of transactions ( $0 ⩽ t n ⩽ 1, 000$ ). Let $λ^{β}$ be the ratio $λ$ obtained in $β$ -th simulation. The average ratio Λ of the total number of meaningless methods for each total number $t n$ of transactions is $\sum_{β = 1}^{10} λ^{β} / 10$ .

Figure 10 shows the average ratio Λ of the total number of meaningless methods in the homogeneous set $S^{H O}$ of servers to perform the total number $t n$ of transactions in the EEQBL-OMM and ECLBQS protocols. For $0 ⩽ t n ⩽ 1, 000$ , the average ratio Λ of the total number of meaningless methods in the ECLBQS protocol is zero since every method issued by each transaction is surely performed on every replica. On the other hand, the average ratio Λ of the total number of meaningless methods in the EEQBL-OMM protocol increases for $0 ⩽ t n ⩽ 200$ . For $200 < t n ⩽ 1, 000$ , the average ratio Λ of the total number of meaningless methods in the EEQBL-OMM protocol is constant. For example, for $t n = 300$ , the average ratio Λ of the total number of meaningless methods in the EEQBL-OMM protocol is 0.48. This means that at most 48% of the total number of methods can be omitted as meaningless methods in the EEQBL-OMM protocol. For $200 < t n ⩽ 1, 000$ , the average value of the average ratio Λ of the total number of meaningless methods in the EEQBL-OMM protocol is 0.44. This means 44% of the total number of methods can be on average omitted as meaningless methods in the EEQBL-OMM protocol for $200 < t n ⩽ 1, 000$ .

Fig. 10.

Average ratio Λ of the total number of meaningless methods in the homogeneous set $S^{HO}$ of servers.

Figure 11 shows the average ratio Λ of the total number of meaningless methods in the heterogeneous set $S^{H E}$ of servers to perform the total number $t n$ of transactions in the EEQBL-OMM and ECLBQS protocols. For $0 ⩽ t n ⩽ 1, 000$ , the average ratio Λ of the total number of meaningless methods in the ECLBQS protocol is zero since every method issued by each transaction is surely performed on every replica. On the other hand, the average ratio Λ of the total number of meaningless methods in the EEQBL-OMM protocol increases for $0 ⩽ t n ⩽ 200$ . For $200 < t n ⩽ 1, 000$ , the average ratio Λ of the total number of meaningless methods in the EEQBL-OMM protocol is constant. For example, for $t n = 400$ , the average ratio Λ of the total number of meaningless methods in the EEQBL-OMM protocol is 0.51. This means that at most 51% of the total number of methods can be omitted as meaningless methods in the EEQBL-OMM protocol. For $200 < t n ⩽ 1, 000$ , the average value of the average ratio Λ of the total number of meaningless methods in the EEQBL-OMM protocol is 0.49. This means 49% of the total number of methods can be on average omitted as meaningless methods in the EEQBL-OMM protocol for $200 < t n ⩽ 1, 000$ .

Fig. 11.

Average ratio Λ of the total number of meaningless methods in the heterogeneous set $S^{HE}$ of servers.

Following the evaluation, the total electric energy consumption of servers, the average execution time of each transaction, and the number of aborted instances of transactions in the homogeneous set $S^{HO}$ and heterogeneous set $S^{HE}$ of servers can be more reduced in the EEQBL-OMM protocol than the ECLBQS protocol. Hence, the EEQBL-OMM protocol is more useful than the ECLBQS protocol.

6. Concluding remarks

In this paper, meaningless methods which are not required to be performed on replicas of each object were newly defined based on the semantics of methods supported by each object and the precedent relation among methods issued by transactions. Then, the EEQBL-OMM (Energy-Efficient Quorum-Based Locking with Omitting Meaningless Method) protocol was newly proposed to furthermore reduce the total electric energy consumption of servers, the average execution time of each transaction, and the number of aborted instances of transactions than the ECLBQS protocol by omitting the execution of meaningless methods on replicas of objects. We evaluated the EEQBL-OMM protocol in terms of the total electric energy consumption of servers, the average execution time of each transaction, the number of aborted instances of transactions, and the ratio of meaningless methods to the total number of methods issued by transactions in sets of homogeneous and heterogeneous servers compared with the ECLBQS protocol. The evaluation results show the total electric energy consumption of servers, the average execution time of each transaction, and the number of aborted instances of transactions in the EEQBL-OMM protocol can be on average reduced to 79%, 62%, and 80% of the ECLBQS protocol in a homogeneous set of servers, respectively. In addition, the evaluation results show the total electric energy consumption of servers, the average execution time of each transaction, and the number of aborted instances of transactions in the EEQBL-OMM protocol can be on average reduced to 73%, 50%, and 67% of the ECLBQS protocol in a heterogeneous set of servers, respectively. The evaluation results show at most 48% and 51% of the total number of methods issued by transaction can be omitted as meaningless methods in a homogeneous set and heterogeneous set of servers, respectively, in the EEQBL-OMM protocol while every method is surely performed in the ECLBQS protocol. Following the evaluation, the EEQBL-OMM protocol is more useful than the ECLBQS protocol where each object is replicated to multiple servers in object-based systems. In high performance, scalable, and fault-tolerant computing systems like cloud and fog computing systems, object replication approaches are widely used to increase availability, reliability, and performance of an application service. The EEQBL-OMM protocol can be applied to increase availability, reliability, and performance of application services designed and implemented on the cloud and fog computing systems.

Conflict of interest

None to report.

References

P.A.

Bernstein,

Hadzilacos and

Goodman, Concurrency Control and Recovery in Database Systems, Addison-Wesley, 1987.

Bylykbashi,

Qafzezi,

Ampririt,

Ikeda,

Matsuo and

Barolli, Effect of vehicle technical condition on real-time driving risk management in Internet of Vehicles: Design and performance evaluation of an integrated fuzzy-based system, Internet of Things 13 (2021), 100363. doi:10.1016/j.iot.2021.100363.

Cuka,

Elmazi,

Ikeda,

Matsuo,

Barolli and

Takizawa, Application of fuzzy logic for IoT node elimination and selection in opportunistic networks: Performance evaluation of two fuzzy-based systems, World Wide Web 24(3) (2021), 929–940. doi:10.1007/s11280-020-00835-6.

K.K.

Désiré,

Dhib,

Tabbane and

Asseu, QoS and QoE aware multi objective resource allocation algorithm for cloud gaming, Journal of High Speed Networks 27(2) (2021), 121–138. doi:10.3233/JHS-210655.

Enokido,

Aikebaier and

Takizawa, A model for reducing power consumption in peer-to-peer systems, IEEE Systems Journal 4(2) (2010), 221–229. doi:10.1109/JSYST.2010.2047296.

Enokido,

Aikebaier and

Takizawa, Process allocation algorithms for saving power consumption in peer-to-peer systems, IEEE Trans. on Industrial Electronics 58(6) (2011), 2216–2225. doi:10.1109/TIE.2010.2051393.

Enokido,

Aikebaier and

Takizawa, An extended simple power consumption model for selecting a server to perform computation type processes in digital ecosystems, IEEE Trans. on Industrial Informatics 10(2) (2014), 1627–1636. doi:10.1109/TII.2014.2303315.

Enokido,

Barolli and

Takizawa, A legal information flow (LIF) scheduler based on role-based access control model, Computer Standards & Interfaces 31(5) (2009), 906–912. doi:10.1016/j.csi.2008.03.013.

Enokido,

Duolikun and

Takizawa, Energy consumption laxity-based quorum selection for distributed object-based systems, Evolutionary Intelligence 13 (2020), 71–82. doi:10.1007/s12065-018-0157-1.

10.

Enokido,

Higaki and

Takizawa, Object-based ordered delivery of messages in object-based systems, in: Proceedings of the 1999 International Conference on Parallel Processing (ICPP-1999), 1989, pp. 380–387.

11.

Enokido,

Inoue,

Aikebaire and

Takizawa, Macro level models of power consumption for servers in distributed systems, in: Evolutionary Based Solutions for Green Computing, Springer, Berlin, Heidelberg, 2013, pp. 55–94. doi:10.1007/978-3-642-30659-4_3.

12.

Enokido and

Takizawa, Role-based concurrency control for distributed systems, in: Proceedings of the 20th IEEE International Conference on Advanced Information Networking and Applications, Vol. 1, 2006, pp. 407–412.

13.

Enokido and

Takizawa, Purpose-based information flow control for cyber engineering, IEEE Transactions on Industrial Electronics 58(6) (2011), 2216–2225. doi:10.1109/TIE.2010.2051393.

14.

Enokido and

Takizawa, The evaluation of the extended transmission power consumption (ETPC) model to perform communication type processes, Computing 95(10–11) (2013), 1019–1037. doi:10.1007/s00607-012-0222-z.

15.

Enokido and

Takizawa, Integrated power consumption model for distributed systems, IEEE Trans. on Industrial Electronics 60(2) (2013), 824–836. doi:10.1109/TIE.2012.2206357.

16.

Enokido and

Takizawa, The redundant energy consumption laxity based algorithm to perform computation processes for IoT services, Internet of Things 9 (2020), 100165. doi:10.1016/j.iot.2020.100165.

17.

Garcia-Molina and

Barbara, How to assign votes in a distributed system, Journal of the ACM 32(4) (1985), 841–860. doi:10.1145/4221.4223.

18.

Gray, Notes on Database Operating Systems, Operating Systems: An Advanced Course, Lecture Notes in Computer Science, Vol. 60, Springer Verlag, 1978, pp. 397–405.

19.

Lamport,

Shostak and

Pease, The byzantine generals problems, ACM Trans. on Programing Language and Systems 4(3) (1982), 382–401. doi:10.1145/357172.357176.

20.

Lee,

Shi,

Tan,

Liu,

Lee and

Cui, S2Net: Preserving privacy in smart home routers, IEEE Transactions on Dependable and Secure Computing 18(3) (2021), 1409–1424.

21.

Nakamura,

Enokido and

Takizawa, Implementation and evaluation of the information flow control for the Internet of Things, in: Concurrency and Computation: Practice and Experience, Vol. 33, 2021. doi:10.1002/cpe.6311.

22.

Niu and

Jiang, Single node repair algorithm for a multimedia cloud storage system based on network coding, Journal of High Speed Networks 27(3) (2021), 205–214. doi:10.3233/JHS-210661.

23.

Oma,

Nakamura,

Enokido and

Takizawa, Fault-tolerant strategies in the tree-based fog computing model, International Journal of Distributed Systems and Technologies (IJDST) 11(4) (2020), 72–91. doi:10.4018/IJDST.2020100105.

24.

R.S.

Sandhu,

E.J.

Coyne,

H.L.

Feinsteink and

C.E.

Youman, Role-based access control models, IEEE Computer 29(2) (1996), 38–47. doi:10.1109/2.485845.

25.

Sawada,

Kataoka,

Duolikun,

Enokido and

Takizawa, Energy-aware clusters of servers for storage and computation applications, in: Proceedings of the 30th IEEE International Conference on Advanced Information Networking and Applications (AINA-2016), 2016, pp. 400–407.

26.

F.B.

Schneider, Chapter 7: Replication management using the state-machine approach, in: Distributed Systems, 2nd edn, ACM Press, 1993.

27.

Siegel, CORBA 3 Fundamentals and Programming, John Wiley & Sons, 2000.

28.

Sun and

Ansari, Green cloudlet network: A sustainable platform for mobile cloud computing, IEEE Transactions on Cloud Computing 8(1) (2020), 180–192. doi:10.1109/TCC.2017.2764463.

29.

Tanaka,

Hasegawa and

Takizawa, Quorum-based replication in object-based systems, Journal of Information Science and Engineering 16(3) (2000), 317–331.

30.

Verma and

Singh, Fuzzy assisted vehicle-id based congestion control scheme (FUZZ-CCS) for CAM broadcast over control channel in VANETs, Journal of High Speed Networks 25(2) (2019), 139–153. doi:10.3233/JHS-190608.

31.

Wang,

Zhou,

Bao,

Chou and

S.S.

Yau, Towards green service composition approach in the cloud, IEEE Transactions on Services Computing 14(4) (2021), 1238–1250. doi:10.1109/TSC.2018.2868356.

32.

Whaiduzzaman,

Farjana,

Barros,

M.J.N.

Mahi,

M.S.

Satu,

Roy and

Fidge, HIBAF: A data security scheme for fog computing, Journal of High Speed Networks 27(4) (2021), 381–402. doi:10.3233/JHS-210673.

33.

Yasuda,

Higaki and

Takizawa, A purpose-oriented access control model for information flow management, in: Proceedings of the 14th IFIP International Information Security Conference (SEC’98), 1998, pp. 230–239.

34.

Zeng,

Chen,

Zhou,

Yang and

Zhang, CoEdge: Cooperative DNN inference with adaptive workload partitioning over heterogeneous edge devices, IEEE/ACM Transactions on Networking 29(2) (2021), 595–608. doi:10.1109/TNET.2020.3042320.

35.

Zhang,

Lan,

Ren and

Cai, Efficient computing resource sharing for mobile edge-cloud computing networks, IEEE/ACM Transactions on Networking 28(3) (2020), 1227–1240. doi:10.1109/TNET.2020.2979807.

An energy-efficient quorum-based locking protocol by omitting meaningless methods on object replicas

Abstract

Keywords

1. Introduction

3. System model

3.1. Object-based systems

Table 2 Conflicting relation among methods read (r) full write ( w f ) partial write ( w p ) read (r) ◯ × × full write ( w f ) × × × partial write ( w p ) × × ×

3.3. Data access model of read and write methods

3.4. Electric power consumption model of a server

4. Energy-efficient protocol

4.1. Quorum selection with the ECLBQS protocol

5.1. Evaluation environment

Table 3 A homogeneous set S HO of servers ( t = 1 , … , 20 ) server s t max R R t max W R t rw t wr t min E t WE t RE t s t 80 [MB/sec] 45 [MB/sec] 0.5 0.5 39 [W] 53 [W] 43 [W]

Conflict of interest

References

Table 2
Conflicting relation among methods

read (r) full write ( $w^{f}$ ) partial write ( $w^{p}$ )

read (r) ◯ × ×

full write ( $w^{f}$ ) × × ×

partial write ( $w^{p}$ ) × × ×

Table 3
A homogeneous set $S^{HO}$ of servers ( $t = 1, \dots, 20$ )

server $s_{t}$ $max R R_{t}$ $max W R_{t}$ ${rw}_{t}$ ${wr}_{t}$ $min E_{t}$ ${WE}_{t}$ ${RE}_{t}$

$s_{t}$ 80 [MB/sec] 45 [MB/sec] 0.5 0.5 39 [W] 53 [W] 43 [W]