This article has been accepted for publication in a future issue of this journal, but has not been
fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017
An Automatic Configuration Algorithm for Reliable
and Efficient Composite Services
Imed Abbassi and Mohamed Graiet
Abstract—Reusability is a central concept of Web services as
it allows for the construction of composite services. Thus, an
existing composite service can be combined with other composite
services to form more complex nested or hierarchical services.
Reliability and efficiency are the main requirements of composite
services construction. The reliability requirements are rigorously
defined by designers using the Accepted Termination States (ATS)
concept. The efficiency requirements are tightly related to a
set of quality-of-service (QoS) constraints that are required by
customers.
In this work, we first developed a hierarchical model for
composite services. Based on this model, we developed a recursive
procedure for the automatic computation of the transactional
reliability and QoS of composite services. Second, we proposed
a new concept, called Required Efficiency Level (REL), to offer
more flexibility to the customers to specify their needs in terms
of QoS. Third, we developed a new Composite Service Config-
uration (CSC) algorithm for the construction and adaptation of
composite services while considering the reliability and efficiency
requirements. The originality of the CSC algorithm consists in
a new recursive global QoS constraint decomposition procedure.
Finally, we conducted a set of experiments to evaluate the benefits
of the proposed CSC algorithm in comparison with the related
work. These experiments confirm that our CSC algorithm is able
to generate, in a timely fashion, reliable and efficient composite
services.
Index Terms—Web Service, Service composition, Reliability,
Efficiency, Constraints decomposition.
I. I NTRODUCTION
W EB services [1] represent the widely used implemen-
tation of service oriented architectures as they offer
diverse functional capabilities (e.g., ticket purchase, hotel
booking), quality of service (QoS) and transactional properties
[2], [3]. Reusability is a central concept of Web services [1]
as it allows for the construction of composite services [4],
[5]. Thus, an existing composite service can be combined
with other composite services to form more complex nested
or hierarchical services.
The reliability and efficiency are the main requirements
of composite services construction [5], [6]. The reliability
requirements are rigorously defined by designers using the
Accepted Termination States (ATS) concept [6]–[8]. They
express which faults are acceptable, retriable, or recoverable.
For example, a service to retrieve customer details can be
retried safely, but services to commit payment or place orders
may require recovery or replacement in case of failure. The
efficiency requirements are tightly related to a set of QoS
I. Abbassi is with the University of Tunis El Manar, National Engineering
School of Tunis, OASIS, Monastir, Tunisia.
M. Graiet is with the University of Monastir, Higher Institute of Computer
Sciences and Mathematics of Monastir, Monastir, Tunisia.
Corresponding author: ABBASSI Imed (email: abbassi.imed@gmail.com
1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
1
constraints required to ensure the customers’ satisfaction [6].
The meaning of efficiency of composite services is therefore
tightly related to the customers’ needs. The existing QoS
specification languages (WSLA [9], SLAng [10], etc) do not
offers mechanisms that deal with this variability issue. Indeed,
SLAng language can be used only for specifying static (shall
remain unchanged) QoS requirements [11]. As claimed in
[12], WSLA language doesn’t offer mechanisms to specify
and capture dynamically the customers’ requirements.
To the best of our knowledge, the process of defining a
composite service, with particular properties like ATS, while
ensuring that every execution preserves these properties re-
mains a difficult and open problem [13], [14]. Extended with
global QoS constraints, the problem becomes more complex
and even NP-hard [6], [15]. Hence, we must ensure that even
in case of failure and dynamic changes (new added computing
requirements, loss of QoS, unavailability, etc.), the composite
service execution usually preserves all defined transactional
and QoS requirements.
To solve the aforementioned problem effectively, we pro-
pose an extension to our previous approach [6]. Contrary to
[6], we make the following contributions:
• First, we propose a hierarchical model for composite
services. The goal of such a model is to facilitate the
manipulation and the automated reasoning about the
structure of composite services. For instance, the ex-
isting literature to compute the QoS and the reliability
of composite services consists in manually defining, at
design time, a set of aggregation functions [16]. However,
these functions need to be completely manually redefined
when the composition model is altered for some reasons.
Thanks to the hierarchical composite service model, we
propose a new recursive procedure which allows to auto-
matically compute, at runtime, the QoS and the reliability
of composite services.
• Second, we extend the Composite Services Configuration
(CSC) problem that we had proposed in [6] with a
new concept called Required Efficiency Level (REL). In
comparison to WSLA and SLAng languages, the REL
concept allows to specify and capture, at runtime, the
QoS requirements.
• Third, we propose an automatic CSC algorithm using
a new recursive global QoS constraint decomposition
procedure. Such a procedure relies on a hierarchical
model for service composition. It allows to effectively
solve the NP-hardness issue of the service composition
and avoid using heuristic methods (genetic algorithms,
particle swarm optimization, etc).
• Fourth, we conduct a set of experiments to evaluate the
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017
benefits of our CSC algorithm in comparison with the
existing related approaches.
In the following section, we present a motivating example and
define the formal notations that will be used throughout the
paper. In Section III, we present our hierarchical composite
service model. Section IV describes the CSC problem ex-
tended with the REL concept. Our CSC algorithm is fully
described in Section V. Its evaluation studies are shown in
Sections VI. In Section VII, we present a review of the
literature. In Section VIII, we draw some conclusions and
provide some perspectives related to our future research.
II. M OTIVATION AND NOTATIONS
In this section, we present a motivating example and a
summary of the formal notations used throughout this paper.
A. Motivating example
Let’s consider an Online Tourist Service (OTS) to illus-
trate all the concepts presented in this paper (see Figure
1). This composite service provides the following functional
capabilities for the online arrangement of tourist-circuits: flight
booking (f1), car reservation (f2), hotel booking (f3), on-line
payment using a credit card (f4) or bank transfer (f5), and
travel documents sending either by post (f6), or via email (f7).
Each functional capability is eventually provided by different
Web services.
Fig. 1. The online tourist service composition model
The execution of the online tourist composite service is
coordinated according to the composition model presented
in Figure 1. Initially, the customer books a flight using the
FB (Flight Booking) service. After the execution of f1, the
functional capabilities f2 and f3 are executed simultaneously.
f3 is in a loop (four iterations at the most are allowed).
f2 and f3 are provided by multiple available Web services
such as the Hotel Booking (HB) and Car Booking (CB)
services. Once all the reservations are successfully made, the
customer is requested to pay via a Credit Card (CC) or a Bank
Transfer (BT) service. Finally, travel documents are sent to the
customer, using the Postal Mail or by the Email Contacting
(EC) service.
When designers specify a composite service, they want
to be sure that its execution is both reliable and efficient.
This means that they pay a particular attention to the failure
execution as well as to the customer’s satisfaction in terms
of QoS. In our example, designers require that the execution
of the online tourist service will successfully complete when
all reservations are made. They offer customers the possibility
1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
2
to cancel the hotel and flight reservations if the car booking
fails. Moreover, they also offer customers the opportunity to
cancel their travel and get compensated for the reservation fees
just before sending travel documents. All these properties are
expressed using the ATS concept (see Table I).
At the same time, and in order to ensure an efficient
composition, the designers of the online tourist service want
that the selected services comply with the QoS constraints
required by the online tourist service’s customers. A few QoS
constraints are listed below:
• C1: the reservation time of the tourist service shall not
exceed a maximum threshold T max.
• C2: the reservation fees of a tourist circuit shall not
exceed a maximum threshold Pmax.
• C3: the online tourist service availability must be usually
larger than a minimum threshold Amin.
These constraints express the efficiency levels imposed by the
customers to guarantee their satisfaction. These levels may
vary from one customer to another. A composite service can
be efficient for one customer and inefficient for another. Some
clients consider a composite service as efficient only if it
respects at least the C1 constraint. Others require the satisfac-
tion of all the QoS constraints. The meaning of efficiency of
composite services is therefore tightly related to the customers’
needs. That being the case, it is necessary to offer customers
a way to express their requirements in terms of QoS.
B. Summary of notations
In this paper, we use a set of mathematical notations to
formally describe our approach. These notations are described
as follows:
• P denotes the power set operator. For a given set A, P( A)
is the set of all the subsets of A.
• a ∈ A× B means a is a relation defined with the following
form a = (x, y), where x ∈ A and y ∈ B.
• R ∈ A ↔ B means R is a set of relations between the sets
A and B.
• f ∈ A → B means f is a total function defined from a set
A to a set B. The domain of f is the set A (dom( f ) = A).
For each element x of A, f (x) denotes the unique element
y of B such that (x, y) ∈ f .
• f ∈ A→ 7 B means f is a partial function defined from
a set A to a set B. The domain of f is a subset of A
(dom( f ) ∈ P( A)). It can be an empty set (when f=∅).
For an element x of dom( f ), f (x) denotes the unique
element y of B such that (x, y) ∈ f .
Other standard mathematical notations (e.g., ∈, <, R+ , N and
⊆) that do not require definition are also used in our approach.
III. H IERARCHICAL MODEL FOR COMPOSITE SERVICES
In this section, we propose an hierarchical model for Web
service composition. Based on this model, we propose a new
recursive algorithm for the automatic QoS computation of the
composite services.
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017 3

TABLE I
T HE TRANSACTIONAL REQUIREMENTS OF THE ONLINE TOURIST SERVICE .

ID f1 f2 f3 f4 f5 f6 f7
ats1 completed completed completed completed initial completed Initial
ats2 completed completed completed completed initial failed completed
ats3 completed completed completed failed completed completed initial
ats4 completed completed completed failed completed failed completed
ats5 Compensated failed canceled initial initial initial initial
ats6 Compensated failed Compensated initial initial Initial initial
ats7 Compensated failed canceled initial initial initial initial
ats8 Compensated Compensated Compensated failed completed initial initial
ats9 Compensated Compensated Compensated completed initial initial initial

A. Web Service properties
Web services are reusable, autonomous and independent
programs that can be automatically discovered and invoked us-
ing Internet protocols [1]. They provide functional capabilities,
QoS and transactional properties. The functional capabilities
of Web services are formally defined using the following
function:
capabilit y ∈ SE RV ICE → C AP ABI LIT I ES
Where SE RV ICE refers to a set of Web services and
C AP ABI LIT I ES represents a set of functional capabilities.
A given functional capability can be provided by several Web
services.
1) Transactional properties: Extended with transactional
properties (TP) [8], [14], Web services can be :
• retriable (r)
• compensatable (c)
• pivot (p)
• retriable and compensatable (cr)
• retriable and pivot (pr)
The reason behind such an extension is to be able to properly
react in case of failure [7], [8]. Thus, the extended Web
services are called transactional Web services. The property
compensatable offers compensation policies to semantically
undo the effects of Web services, while pivot has the opposite
semantics of compensatable (e.g., once a Web service is suc-
cessfully completed, its effects persist and cannot be seman-
tically undone). The property retriable makes it possible to
retry Web services’ execution until they complete successfully.
We formally model the Web services TP as the following
function:
T P ∈ SE RV ICE → {c, p,r, pr, cr } (2)
Web services can combine several transactional properties,
which leads to a new behavioral property. For instance, a
service can be pivot and retriable (TP(ts)=pr). Similarly, a
service can be compensatable and retriable which leads to a
new behavior (TP(ts)=cr). However, compensatable and pivot
should be exclusive properties.
2) QoS properties: In addition to the functional capabilities
and transactional properties, Web services can have a set of
QoS properties [2], [3]. In this paper, we focus on the most
widely used quantitative QoS properties listed below:
• Response time (T) is the time interval between receiving
the client request and sending the response [2], [3].
• Price (P) is the price of invoking Web services [2].
• Availability (A) is the probability that a Web service is
available for use. This probability is computed as the
ratio of the number of successful invocations to the total
invocations [2], [3].
In what follows, we denote by QWS the set of Web services’
QoS quantitative properties. These QoS properties can be
classified into two categories, namely the positive properties
(1) (availability) denoted by the set QW S+ and the negative
properties (price and response time) denoted by the set QW S−
(QW S = QW S+ ∪ QW S− ). For positive properties, higher
values indicate higher efficiency. For negative properties, lower
values indicate higher efficiency.
B. Hierarchical composite services model
A Composite Web Service (CS) [4] is an orchestration of a
set of existing web services to provide a complex functional
capability. It can be transactional when all its components
exhibit a transactional behavior [8]. In this case, a transactional
CS exploits the transactional properties of its components in
order to define recovery strategies.
1) Hierarchical model: Composite services’ structures are
often complex. For instance, a composite service can be
combined with other composite services to form nested or hi-
erarchical services. A hierarchical model is therefore required
to simplify the automated reasoning about the structure of
composite services. Such a model needs to capture not only the
hierarchy, but also the relation between functional capabilities.
Definition 3.1: We formally define a hierarchical service
composition model M as the following quadruplet: M =
(C AP ABI LIT I ES,Ctree, It, Pr), where:
• CAPABILITIES={ f 1 , . . . , f m } is a set of functional
capabilities. Each capability is provided by an existing
(simple or composite ) service.
• Ctree=(root, hasCapabilities, hasType, DS) is the capabil-
ity tree hierarchically describing the provided functional
capabilities, where:
– root∈ CAPABILITIES is the most complex functional
capability representing the tree root.
– hasCapabilities ∈ CAPABILITIES → P (CAPABILI-
TIES) is a function defining the set of sub-functional
capabilities of a given functional capability. Each
functional capability can be either a leaf node or an
inner node in the Ctree.

1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017 4

– hasType ∈ CAPABILITIES → {simple, sequence,

loop, switch, flow} is a function defining the types
of each functional capability. A functional capability
f can be simple (hasType(f)= simple), or complex
(hasType(f) ∈ {sequence, loop, switch, flow}). The
complex types of functional capabilities are the
composition patterns. In this work, we consider the
patterns that cover most of the structures specified
by composition languages such as BPEL [17], [18].
We assume that each case statement in the switch
construct is defined by the execution’s probability.
– DS ∈ CAPABILITIES ↔ CAPABILITIES is a set
dependency relations defined only between the ele-
ments of functional capability of sequence or switch
type. These relations are mandatory for the coordi-
nation of composite services’ executions.
• It ∈ CAPABILITIES →N 7 is a function defining the
number of iterations of functional capabilities that are
under a loop.
Fig. 2. The hierarchical definition of the OTS composition model
• Pr ∈ CAPABILITIES → 7 [0,1] is the execution proba-
bilities function of each functional capability f of type
switch (hasType(f) = switch), such that: capabilities, namely f4 and f5 (hasCapabilities(fu2) = {f4,f5}).
X fu3 is composed of two simple functional capabilities, namely
Pr ( f i) = 1 (3) f6 and f7 (hasCapabilities(fu3) = {f6,f7}).
f i ∈hasC a pabil it ies( f )

Definition 3.2: We formally define a composite service CS Algorithm 1 Recursive computation algorithm of composite
as the following triplet: CS = (M, ES, SB), where: services quantitative properties
1: procedure AGGREGATE VALUE(C S = (M, E S, S B), r oot, pr o p )
• M is the implemented hierarchical service composition 2: if hasT y pe(r oot ) = si m pl e then
model. 3: return pr o p(S B(r oot ))
4: else
• ES is the set of component services. 5: com pl e xT y pe ← hasT y pe(r oot )
• SB ∈ C AP ABI LIT I ES → 7 ES is a binding function 6: o per at or ← getO per at or (pr o p, com pl e xT y pe)
7: FC ← hasC a pabil it ies(r oot )
defining the link between the hierarchical model M and 8: if o per at or = sum then
the Web services set ES. 9: V ←0
10: for all f i ∈ FC do
For further explanation, the OTS composition model can be 11: V ← V + aggr egat eV alue(C S, f , pr o p)
12: end for
hierarchically defined (see Figure 2). This is done by reducing 13: return V
each pattern of the workflow shown in Figure 1 into a single 14: end if
15: if o per at or = pr oduct then
unit. As shown in Figure 2a, the reduction process consists in 16: V ←1
three steps. The first step consists in reducing the loop pattern 17: for all f ∈ FC do
18: V ← V ∗ aggr egat eV alue(C S, f , pr o p)
into a single unit called fu0. At the second step, we reduce 19: end for
the flow pattern and the two switch patterns into the following 20: return V
21: end if
single units: fu1, fu2 and fu3. The OTS composition model is 22: if o per at or = power then
then reduced into a sequence of capabilities f1, fu1, fu2 and 23: k ← I t (r oot )
24: f ← getC a pabil it yU nder Loo p(r oot )
fu3. At the third step, we further reduce such a sequence into 25: return (aggr egat eV alue(C S, f , pr o p)) k
a single unit called OTS. 26: end if
27: if o per at or = l oo p Pr oduct then
Figure 2b presents the capability tree of the OTS hi- 28: k ← I t (r oot )
erarchical model. Such a tree is constructed according to 29: f ← getC a pabil it yU nder Loo p(r oot )
30: return (aggr egat eV alue(C S, f , pr o p)) ∗ k
hierarchy and dependency relations. The dependency re- 31: end if
lations are expressed using the set DS as follows: DS= 32: if o per at or = min then
33: V ← min({ f ∈ FC |aggr egat eV alue(C S, f , pr o p)})
{(f1,fu1),(fu1,fu2),(fu2,fu3),(f4,f5),(f6,f7)}. 34: return V
The single unit OTA is the root node tree, while the leaves 35: end if
36: if o per at or = ma x then
are the simple functional capabilities (f1, f2, f3, f4, f5, f6 and 37: V ← ma x ({ f ∈ FC |aggr egat eV alue(C S, f , pr o p)})
f7) and the inner nodes are the complex ones (fu0, fu1, fu2 and 38: return V
39: end if
fu3). The single unit fu0 is of loop type (hasType(fu0)=loop, 40: end if
It(fu0)=4) and includes a simple functional capability, namely 41: end procedure
f3 (hasCapabilities(fu0) = {f3}). fu1 is composed of two
sub-functional capabilities, namely f2 and fu0 (hasCapabili- 2) Computing QoS of composite services: The current
ties(fu1) = {f2,fu0}). fu2 is composed of two sub-functional method to compute the composite service QoS consists in

1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017
statically defining a set of aggregations functions. However,
these functions need to be completely redefined when the
composition model is changed. To solve this issue, we propose
a practical solution based on the hierarchical composite service
model. The solution consists in a new recursive procedure (see
Algorithm 1). The input parameters of this procedure are the
following: a composite service (CS = (M, ES, SB)), the root
node of the capability tree (root) and a quantitative property
(prop). The aggregation process is carried out by applying the
following operators:
1) sum: the aggregate value of the property prop at an
inner node of the tree is computed as the sum of the
aggregate values of the child nodes (see Algorithm 1,
from line 8 to 14).
2) product: the aggregate value of the property prop at an
inner node of the tree is computed as the results of the
product of the aggregate values of the child nodes (see
Algorithm 1, from line 15 to 21).
3) power: the aggregate value of the property prop at an
inner node of the tree is the power of the aggregate value
of the child node by a natural number k (see Algorithm
1, from line 22 to 26).
4) loopProduct: the aggregate value of the property prop
at an inner node of the tree is the product of the
aggregate value of the child node by a natural number
k (see Algorithm 1, from line 27 to 31).
5) min: the aggregate value of the property prop at an inner
node of the tree is the smallest aggregate value of the
child nodes (see Algorithm 1, from line 32 to 35).
6) max: the aggregate value of the property prop at an
inner node of the tree is the largest aggregate value of
the child nodes (see Algorithm 1, from line 36 to 39).
These operators are identified and inspired from the litera-
ture and particularly [16]. They are the most frequently and
even the only used operators in the QoS computation. The
loopProduct is a variant of the sum operator.
The aggregation process is done by going through the
capability tree Ctree from the root to the leaf nodes (simple
functional capabilities). When root is a simple functional
capability (Algorithm 1, see line 2), It returns the follow-
ing output value: prop(SB(root)). When root is a complex
functional capability, it starts by calling itself, for each sub-
functional capability f of root ( f ∈ hasCapabilities(root)),
to compute the value of aggregateV alue(CS, f , prop). After
that, it applies the appropriate operator to compute the aggre-
gated value of the property prop. The operator to be applied is
determined using the getOperator procedure (see Algorithm
1, line 6). It depends on the complex type of the inner node (a
complex functional capability) and on the property prop. As
claimed in [16], the aggregation operators to be applied to the
response time, price and availability are presented in Table II.
Theorem 3.1: The runtime complexity of the aggregateValue
procedure is O(n+m), where n and m represent respectively the
number of leaf and inner nodes of the capability tree Ctree.
Proof: The aggregateV alue procedure follows a pre-
order traversal method of Ctree. The runtime complexity of
the preorder traversal method is known to be O(n + m) [19].
1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
5
TABLE II
T HE Q O S AGGREGATION OPERATORS PER COMPLEX TYPES
Complex types
flow sequence switch loop
Properties
Response time (T) max sum sum loopProduct
Price (P) sum sum sum loopProduct
Availability (A) product product sum power
So, the runtime complexity of the aggregateV alue procedure
is O(n + m).
It is worth emphasizing that the use of the aggregateV alue
procedure is not limited to the QoS properties. Hence, we
describe later how this procedure could be used for the
automatic reliability computation of composite services.
IV. CSC PROBLEM
In this section, we extend the CSC problem that proposed
in [6] with an REL (Required Efficiency Level) concept to
deal with the variability of efficiency requirements. We start by
presenting the efficiency and reliability requirements. Then, we
present an overview and the formulation of the configuration
problem.
A. Reliability requirements for composite services
Reliability is one of the fundamental challenges of compos-
ite services. As stated in [6], [8], the transactional requirements
can be used as concrete parameters to meet the reliability
requirement. They are properly defined by the designers based
on a service composition model M using the Accepted Termi-
nation States (ATS) concept [7], [8]. We formally define the
ATS concept as the following set of functions:
AT S ∈ P(C AP ABI LIT I ES → ST AT E) (4)
where ST AT E refers to the set of all possible execution states
of Web services, namely initial, activated, canceled, aborted,
failed, completed, and compensated. An element x of the
ATS set (x is a function defined from the set CAPABILITIES
to STATE) specifies a possible execution state in which the
designers tolerate the termination of the composite service
implementing the model M.
1) ATS validity rules: The ATS concept allows to define
a valid global transactional behavior for composite services
from the designers’ point of view [8], [14]. To meet such a
validity, the following four rules shall be used while defining
the ATS set for a composition model M:
• The retriability shall be required for at least one sub-
functional capability of a complex one with a switch type
[8], [14].
• If the retriability and the compensability are not required
for a functional capability f , then:
– The compensability and the retriability properties
must be required for all functional capabilities exe-
cuting in parallel and in synchronization with f [14],
[20].
– At least the compensability is required for all func-
tional capabilities executing before f [14], [20].
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017 6

• If the retriability is required and the compensability is Algorithm 2 Web service reliability computation algorithm
not required for a functional capability f , the retriability 1: procedure CHECK R ELIABILITY( s, AT S )
2: V ←0
must be also required for all the other parallel and 3: f ← ca pabil it y (s)
synchronized functional capabilities [20]. 4: ST S ← {at s( f ) |at s ∈ AT S ∧ f ∈ dom(at s)}
5: if f ail ed < ST S ∧ com pensat ed ∈ ST S then
• If the compensability is not required for a functional 6: if T P(s) = cr then
capability f , then we have to ensure that after a successful 7: V ←1
8: end if
execution of the composite service implementing M, it is 9: else if f ail ed < ST S ∧ com pensat ed < ST S then
able to complete normally its execution even with the 10: if T P(s) ∈ {r, pr, cr } then
11: V ←1
failure of some components [14], [20]. 12: end if
13: else if f ail ed ∈ ST S ∧ com pensat ed ∈ ST S then
Table I gives examples of valid ATS defined for the on- 14: if T P(s) ∈ {c, cr } then
line tourist service. These particular requirements assert that 15: V ←1
16: end if
designers accept the failure of car booking services while 17: else
they require the compensation of flight and hotel reservations. 18: V ←1
19: end if
However, they do not accept the failure of the online payment 20: return V ;
service (the retriability is required for the functional capability 21: end procedure
f5). They do not accept the failure of travel documents sending.
When the service providing f6 fails, the service providing f7 is
executed as an alternative. It is sure to complete successfully service, while the global ones are specified at the composition
since the retriability is required for f7. level.
2) Reliability computation according to ATS: Another prac- 1) Defining QoS requirements: The meaning of service ef-
tical use of the proposed hierarchical model is the automatic ficiency is tightly related to the defined QoS requirements and
reliability (R) computation of a given composite service. For may vary from one customer to another. For instance, some
a composite service CS = (M, ES, SB), the value of R(CS) customers may consider the online tourist service efficient only
is computed by the proposed aggregateV alue procedure (see if it respects at least the C1 constraint. Others may require
Algorithm 1) based on the aggregation operator described in the satisfaction of all the QoS constraints. In addition, the
Table III. maximum threshold levels of response time and price defined
by the constraints C1 and C2 may be unacceptable for some
TABLE III customers. To solve this issue, we define a new concept called
T HE RELIABILITY AGGREGATION OPERATORS PER COMPLEX TYPES Required Efficiency Level (REL) as a means to specify the
flow sequence switch loop QoS requirements.
product product sum power Definition 4.1: We formally define the REL concept as the
following function:
The service reliability can be computed using the
REL ∈ (P(C AP ABI LIT I ES) × QW S) → R+ (5)
check Reliabilit y procedure (see Algorithm 2) according to a
set requirements defined by designers using the ATS concept. where R+ denotes the set of all real positive numbers.
Such a computation is done using the following rules: Definition 4.2: A QoS constraint C can be defined using the
• If both retriability and compensability are required for a REL concept as follows: C = (( f , p), l), where:
functional capability f , then a service providing f must • f = { f 1 , ..., f p } is a functional capability that can be
be both compensatable and retriable (see Algorithm 2, either simple (| f | = 1), or complex (| f | ≥ 2).
line 5). • p ∈ QW S is a QoS property like the response time, price,
• If only the retriability is required for a functional capabil- and so on.
ity f , then a service providing f must be at least retriable • l = REL( f , p) is the efficiency level required for the
(see Algorithm 2, line 9). property p of the service providing f .
• If only the compensability is required for a functional A constraint C = (( f , p), l) is global when f is provided by
capability f , then a service providing f must be at least composite services and local otherwise. It can be a Lower-
compensatable (see Algorithm 2, line 13). Bound Constraint (LBC) if p is a positive QoS property (p ∈
• If neither retriability nor compensability is required for a QW S+ ), or an Upper-Bound Constraint (UBC) otherwise.
functional capability f , then there is no transaction needs 2) Composite services efficiency computation: The effi-
on the services providing f (see Algorithm 2, line 17). ciency of a composite service cs (E(cs)) is computed as the
ratio of the number of the satisfied constraints to the total
number of constraints:
B. Efficiency requirements for composite services
S AT (cs, (( f , p), l))
P
Efficiency is another crucial requirement for composite (( f , p),l )∈ RE L
services. As stated in [6], QoS requirements can be used as E(cs) = (6)
|REL|
concrete parameters to meet the efficiency requirement and
Where S AT is the satisfiability function, which returns 1 if
to guarantee customers’ satisfaction. These QoS requirements
the following condition is fulfilled and 0 otherwise:
are defined as a set of local and global constraints [6], [15].
The local constraints are defined for the QoS of a simple Web (p(cs) ≤ l ∧ p ∈ QW S− ) ∨ (p(cs) ≥ l ∧ p ∈ QW S+ ) (7)

1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017 7

This condition is called the constraint satisfiability condition. Where α c (α c ∈ [0, 1]) refers to the penalty factor of the
All efficiency values are between 0 and 1. The value 1 indi- constraint c. The term D(cs, c) denotes the efficiency distance.
cates a perfect efficiency while 0 expresses a total inefficiency. For a constraint C = (( f , p), l), the value of D(cs, c) is
computed as the difference between the required efficiency
C. Overview of the CSC problem value (l) and the one supplied by the service (p(cs)):


The service deployment and executing environments are 
 (p(cs) − l), if p ∈ QW S+
D(cs, (( f , p), l)) =  (9)
usually dynamic [21]–[23]. Thus, several unexpected changes 
 (l − p(cs)), if p ∈ QW S−
may occur while executing composite services. The following
description expresses the reasons that cause the changes but The CSC process is an optimization problem where the goal is
not the changes themselves: to generate a composite service cs that is reliable (R(cs) = 1)
and efficient (E(cs) = 1) while optimizing the OF function. It
• The loss of efficiency caused mainly by the problem of
is proved in [6] that this problem is NP-hard. The NP-hardness
the variability of the QoS properties [24].
issue is basically caused by the global QoS constraints.
• The unavailability of some components (Web services)
for multiple reasons such as customer mobility, commu-
nication network failure, service maintenance, etc. V. AUTOMATIC CSC ALGORITHM
• The discovery of new Web services, which are more In this paper, we propose a practical algorithm to effectively
efficient and reliable than some of the components. solve the CSC problem (see Algorithm 3). Such an algorithm
• The modification of the transactional or QoS require- is based on a new recursive global QoS constraint decom-
ments of the service composition. position procedure. This procedure relies on the hierarchical
All of these changes can make a composite service either model for service composition. It allows to avoid the use of
unreliable or inefficient. Functional capabilities, provided by heuristic approaches (e.g., genetic algorithms, ant colonies,
unreliable or ineffective components, are said to be invalid. etc.) and consequently perform an optimal local selection of
In the rest of the paper, we denote by CF I the set of invalid Web services.
functional capabilities.
Algorithm 3 An automatic CSC algorithm
We proposed in [6] a new approach in order to meet the
1: er r or ← f al se ;
following objectives: 2: GC ← getGl obalC onst r aint s(RE L, M ) ;
3: for all C ∈ GC do
• Defining new composite services.
4: if ( decom posabl e(C ) = t r ue then
• Adapting an existing composite service for correction 5: RE L ← RE L ∪ decom pose(C, M ) ;
6: RE L ← RE L \ {C } ;
reasons, such as loss of efficiency, unavailability or 7: else
execution failure of some components. 8: er r or ← t r ue ;
9: end if
• Increasing the efficiency and the reliability of an existing
10: end for
composite service. 11: con f ig 0 ← (M, ∅, ∅) ;
12: if er r or = f al se then
To achieve these three objectives, we used the concept of 13: er r or ← check ( AT S, RE L, C F I ) ;
configuration. A configuration con f ig can either be an existing 14: if er r or = f al se then
15: E S 0 ← E S \ {s |ca pabil it y (s) ∈ C F I }
composite service, or be the initial configuration. It is defined 16: S B 0 ← {( f , s) | s ∈ E S 0 ∧ ( f , s) ∈ S B}
as the following triplet: con f ig = (M, ES, SB) where ES is a 17: for all f ∈ C F I do
18: V S ← {s | s ∈ S E RV IC E ∧ R(s) = 1 ∧ E (s) = 1 ∧ f =
set of Web services, SB is the binding function and M is a ca pabil it y (s)} ;
service composition model. (M, ∅, ∅) denotes the initial con- 19: best ← argmax s ∈V S (OF (s)) ;
20: S B 0 ( f ) ← best ;
figuration. The initial configuration is the starting point of our 21: E S 0 ← E S ∪ {best } ;
configuration process. Indeed, the service composition (first 22: end for
23: con f ig 0 ← (M, E S 0, S B 0 ) ;
objective) consists in reconfiguring the initial configuration. 24: end if
The constructed configuration of a composite service can then 25: end if
26: return con f ig 0 ;
be adapted (second objective) or improved (third objective).

D. CSC problem formulation

A. Algorithm description
The CSC process could be formulated by the following
quintuplet: (config, CFI, ATS, REL, OF ), where: The CSC algorithm takes four parameters as input: a
configuration con f ig, a set of invalid functional capabilities
• con f ig is the initial configuration, or an existing com-
CF I, reliability and efficiency requirements (AT S and REL).
posite service.
It returns a new configuration con f ig 0 that complies with ATS
• CF I is a set of invalid functional capabilities.
and REL while optimizing OF. The construction of the new
• AT S denotes the transactional requirements.
configuration con f ig 0 takes three steps:
• REL denotes the efficiency requirements.
• Step 1 (see Algorithm 3, from line 1 to 10): Global QoS
• OF is an optimization function defined as follow:
X constraints decomposition.
OF (cs) = D(cs, c) ∗ α c (8) • Step 2 (see Algorithm 3, from line 11 to 13): Reliability
c ∈ RE L and efficiency verification.

1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017
• Step 3 (see Algorithm 3, from line 14 to end): Selection
and configuration.
In the next subsections, we present a detailed description of
each step.
1) Global QoS constraints decomposition: The first step
of our algorithm is to decompose the set of global QoS
constraints, GC, into local ones using Algorithm 4. Unlike
the approach [25], our decomposition algorithm is able to
decompose UBC and LBC global constraints.
The decomposition algorithm uses the following two oper-
ators: get Max and get Min. These operators take two param-
eters, a QoS property p and a (simple or complex) functional
capability f , as input:
• get Min(p, f ) is the service providing f and has the
smallest value of p.
• get Max(p, f ) is the service providing f and has the
largest value of p.
The decomposition of a global constraint C starts by checking
the following two decomposability conditions (see Algorithm
3, line 7):
• p ∈ QW S− ⇒ p(get Min(p, f )) ≤ l
• p ∈ QW S+ ⇒ p(get Max(p, f )) ≥ l
The decomposition process behaves similarly to the aggregate-
Value procedure. Hence, it follows a preorder traversal method
of Ctree while using a set of rules. These rules depend tightly
on the type of constraint to be decomposed (UBC or LBC).
Definition 5.1 (UBC decomposition rules): Let C =
(( f , p), l) be a global UBC constraint. According to [25], C
can be decomposed into a set of local UBC constraints using
the two following rules:
• Rule 1: if p(get Max(p, f )) ≤ l, then the REL (required
efficiency level) li for the property p of each sub-
functional capability f i must be computed as follows:
REL( f i, p) = p(get Max(p, f i))
• Rule 2: if p(get Max(p, f )) ≥ l and p(get Min(p, f )) ≤
l, then the REL for the property p of each sub-functional
capability f i must be computed as follows by applying
an equitable distribution of l:
p(get Max(p, f i))
REL( f i, p) =
p(get Max(p, f ))
Definition 5.2 (LBC decomposition rules): Let C =
(( f , p), l) be a global LBC constraint. C can be decomposed
into a set of local LBC constraints using the following rules:
• Rule 3: if p(get Min(p, f )) ≥ l, then the REL for the
property p of each sub-functional capability f i must be
computed as follows:
REL( f i, p) = p(get Min(p, f i))
• Rule 4: if p(get Min(p, f )) ≤ l and p(getMax(p,f)) ≥ l
and getOperator(p,hasType(f)) ∈ {sum, loopProduct, min,
max}, then the REL for the property p of each sub-
functional capability f i must be computed as follows:
p(get Min(p, f i))
REL( f i, p) =
p(get Min(p, f ))
1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
Transactions on Network and Service Management
8
• Rule 5: if p(get Min(p, f )) ≤ l and p(getMax(p,f))
≥ l and getOperator(p,hasType(f))∈ {product, power},
then the REL for the property p of each sub-functional
capability f i must be computed as follows:
l n( p (get M i n( p, f i)))
REL( f i, p) = l l n( p (get M i n( p, f ))) (14)
Due to the lack of space, we only include the proof for the
rules 3, 4 and 5.
Proof: An LBC constraint, defined on a positive QoS
property p, is a maximization-based constraint (the best service
is that having the largest value of p). The values of p
of all of the composite service providing f belong to the
interval [p(get Min( f i, p)), p(get Max( f i, p))]. Hence, two
main cases can be identified while decomposing an LBC
constraint C: (1) all existing composite services compliant
with C (p(get Min( f , p)) is larger than l) and (2) some of
the existing composite services are not compliant with C
(p(get Min( f , p)) is strictly smaller than l). In the first case,
the appropriate REL value (required efficiency level) li for the
property p of each sub-functional capability f i is intuitively
equal to p(get Min( f i, p)). In the second case, two further
sub-cases must be considered: (2a) the aggregation operator
(to be applied for f and p) is either max, min, loopproduct (a
variant of sum) or sum, and (2b) the the aggregation operator
is power or product. In the sub-case 2a, the decomposition
of the constraint C consists in an equitable distribution of the
global level (l) to define the appropriate local REL value for
each sub-functional capability f i of f (REL( f i, p)). Such an
equitable distribution consists in the product of l and the ratio
of p(get Min( f i, p)) to p(get Min( f , p)). Such a distribution
guarantees the satisfaction of decomposed global constraint.
In the sub-case 2b, the decomposition process of C consists
in determining the REL of each sub-functional capability f i
of f , REL( f i, p), while satisfying the following formula:
m
(10) Y
REL( f i, p) ≥ l (15)
i=1
By applying the natural logarithm function (ln), we transform
the formula (15) into a sum-based one in order to apply the
rule 4. The following is the result of the transformation:
m
X
∗l (11) zi ≥ z (16)
i=1
where zi = ln(REL( f i, p)) and z = ln(l). By applying the
principle of rule 4, the value of zi that satisfies the formula of
equation (16) is computed as follows:
ln(p(get Min(p, f i)))
zi = ∗z (17)
ln(p(get Min(p, f )))
To obtain the value of li, we have to apply the inverse function
(12) of the natural logarithm, exponential (e) , on zi:
l n( p (get M i n( p, f i)))
REL( f i, p) = e l n( p (get M i n( p, f ))) ∗l n(l ) (18)
We know that ea∗b = (ea ) b and el n(a) = a (a and b are real
positive numbers). Using these two properties, the value of li
is simplified as follows:
∗l (13) l n( p (get M i n( p, f i)))
REL( f i, p) = l l n( p (get M i n( p, f ))) (19)
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017 9

The equations 18 and 19 are semantically equivalent. Algorithm 5 Web service reliability and efficiency verification
Recursive decomposition: The decomposition process is algorithm
carried out recursively using the rules described above. This 1: procedure CHECK( AT S, RE L, C F I )
2: V ← f al se
is done by going through the capability tree Ctree from the 3: PS ← {s | s ∈ S E RV IC E ∧ ca pabil it y (s) ∈ C F I }
root to the leaf nodes (simple functional capabilities). For each 4: for all s ∈ PS do
5: R(s) ← check Rel iabil it y (S, AT S)
sub-functional capability f i of f ( f i ∈ hasCapabilities( f )), 6: E (s) ← check E f f icienc y (S, RE L)
a new QoS constraint Ci = (( f i, p), REL( f i, p)) is generated 7: end for
8: C F = {ca pabil it y (s) | s ∈ PS ∧ R(s) = 1 ∧ E (s) = 1}
using the appropriate decomposition rule (based on the func- 9: if ca pabil it y[C F] , C F I then
tional capability type and the QoS property class). The gener- 10: V ← t r ue
11: end if
ated constraint Ci can be added to the set of local constraints 12: return V ;
LC when f i is simple (hasType(fi)=simple). When f i is a 13: end procedure
complex functional capability, the decomposition procedure
calls itself to further decompose the global constraint Ci. This
process is repeated for all the other sub-functional capabilities Web service efficiency is checked using the check E f f iciency
of f . procedure (see Algorithm 6). For each service s, the verifica-
tion starts by determining the set of the local QoS constraints
Algorithm 4 global QoS constraints decomposition algorithm (LC(s)) defined for the QoS properties of s. The efficiency of
the service s is either equal to 1 when the set LC(s) is empty,
1: procedure DECOMPOSE(C = (( f , p), l ), M ) or is computed as the ratio of the number of the satisfied
2: LC ← ∅
3: for all f i ∈ hasC a pabil it ies( f ) do constraints to the total number of constraints (|LC(s)|).
4: t y pe ← hasT y pe( f )
5: RE L( f i, p) ← com put e RE L( f i, l, t y pe) Algorithm 6 Web service efficiency verification algorithm
6: C i ← (( f i, p), RE L( f i, p))
7: if t y pe = si m pl e then 1: procedure CHECK E FFICIENCY( s, RE L )
8: LC ← LC ∪ {C i } 2: LC (s) ← {(( f , p), l ) | (( f , p), l ) ∈ RE L ∧ f = ca pabil it y (s)}
9: else 3: if LC (s) , ∅ then
10: LC ← LC ∪ decom pose(C i, M ) 4: V ←0
11: end if 5: for all c ∈ LC (s) do
12: end for 6: V ← V + S AT (s, c)
13: return LC 7: end for
14: end procedure 8: return | LCV(s) |
9: else
10: return 1
The number of the decomposition procedure calls depends 11: end if
12: end procedure
on the number of inner nodes of the capability tree Ctree. For
example, the constraint C1 of the online tourist service can
3) Selection and configuration: The last step of our CSC
be decomposed by five recursive calls to the decomposition
algorithm is to select the appropriate Web services providing
procedure:
the set of invalid functional capabilities CF I in order to
1) First call: compute the REL of the functional capabilities build the new composite service configuration con f ig 0 . This
f 1, f u1, f u2 and f u3. construction can only be done if there exists a reliable and
2) Second call: decompose the global constraint defined at efficient service for each functional capacity (see Algorithm
the first call on the functional capability f u1. 3, line 14). The reliable and efficient Web services that
3) Third call: decompose the global constraint defined for maximize the OF optimization function are finally selected.
at the second call on the functional capability f u0. The construction of con f ig 0 consists in defining the set ES 0
4) Fourth call: decompose the global constraint defined at and the service binding function SB 0 .
the first call on the functional capability f u2.
5) Fifth call: decompose the global constraint defined at
the first call on the functional capability f u3. B. Runtime complexity analysis
The number of the decomposition procedure calls is equal to The runtime complexity of the proposed CSC algorithm
the number of inner nodes (OTS, fu0, fu1, fu2 and fu3) of the depends basically on the following five parameters:
capability tree Ctree. 1) The number of global QoS constraints to be decomposed
2) Reliability and efficiency verification: The second step of (k).
our CSC algorithm concerns the verification of the reliability 2) The number of leaf nodes defined in Ctree (n).
and the efficiency of all potential Web services (PS) provid- 3) The number of invalid functional capabilities belonging
ing the set of functional capabilities CF I using the check to the set CF I. This number is equal to |CF I | that is
procedure (see Algorithm 5). It is executed only when all smaller than n (|CF I | ≤ n).
global constraints are correctly decomposed (error = f alse). 4) The number of inner nodes defined in Ctree (m).
The check procedure returns true when there exists at least 5) The number of available Web services for each simple
one reliable and efficient candidate service per functional functional capabilities (p).
capability, and returns f alse otherwise. As described above, our CSC algorithm is executed in three
Our CSC algorithm uses the check Reliabilit y procedure to steps (constraint decomposition, efficiency and reliability ver-
verify the reliability of Web services (see Algorithm 2). The ification and Web service selection and configuration). Its

1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017 10

runtime complexity is therefore computed as the sum of these
three steps. The runtime complexity of the recursive decom-
position procedure is O(m + n). Indeed, the decomposition
procedure follows a preorder traversal method. The runtime
complexity of the preorder traversal method is known to be
O(n + m), where m + n denotes the total number of nodes
defined in the tree [19]. As the decomposition procedure is re-
peated k times, the complexity of the first step is O(k ∗(n+m)).
The second step consists in verifying k ∗ n local constraints for
all available p services. So, the complexity of the verification
step is O(k ∗ n ∗ p). The third step is a simple loop with |CF I |
iteration. Its runtime complexity is equal to O(|CF I |).
To summarize, the complexity of the proposed CSC algo-
rithm is O(k ∗ (n + m) + |CF I | + k ∗ n ∗ p) that is equivalent to
O(k ∗ (n + m + p)). In particular, it is linear with the number of
inner nodes (m) defined in the Ctree (capability tree) of the
hierarchical model. We will investigate later the impact of the
variation of this number on the computation time of our CSC
algorithm.
precision and recall. The precision is the probability that a
solution identified by the procedure as satisfactory is in fact
satisfactory, while the recall is the ability of the procedure to
retrieve at least one satisfactory solution when one exists. We
computed these empirical parameters as follows:
NFIS
Recall = (20)
N FS
NU I S
Precision = 1 − (21)
NIS
Where N FS denotes the number of feasible solutions. N F I S
denotes the number of identified solutions that are feasible.
N I S is the number of identified solutions and NU I S represents
the number of unsatisfactory (unfeasible) solutions among
those identified by the procedure. The probability to reject
a feasible solution by the decomposition procedure can be
computed as follows: 1 − Recall

VI. E VALUATION S TUDIES

In this section, we conduct empirical studies to valuate the
performance and the benefits of the proposed CSC algorithm
in comparison with the closely related approaches.

A. Empirical settings
The conducted empirical studies were performed on a
computer with Pentium 4, 2.8 GHz, 4 GB of RAM, Windows
8 professional edition. Our CSC algorithm is implemented
using the MATLAB platform (version R2009a) and evaluated
on the QWS database [3] that we synthesized with hierar-
chical composition models with different complexity levels. Fig. 3. The evaluation results of the decomposition procedure in terms of
We express the complexity level of a hierarchical model precision and recall
M = (C AP ABI LIT I ES,Ctree, It, Pr) by the number of the
Figure 3 reports the evaluation results of the decomposition
Complex Functional Capabilities (CFC) defined in Ctree. We
procedure in terms of precision and recall. These results show
denote this number by m.
high precision levels of our decomposition procedure. We
The advantage of using the aforementioned synthesis is that
remark that all the identified solutions, for each value of
it is easier that way to fix and modify external factors such
m, are feasible. However, some existing feasible solutions
as functional capabilities, and so on. Thus, a diversity of Web
are not identified by CSC algorithm. Indeed, the evaluation
service compositions and a better validation are ensured [6].
results state that the recall of the decomposition procedure
For the sake of simplicity, the transactional properties of each
is usually in the interval [0.95, 1]. This implies a weak
Web service in the database are generated randomly from
possible rejection of some existing solutions to the CSC
the set {r, c, p, pr, cr } while considering the following QoS
problem. The rejection possibility is basically caused by the
properties: response time, price and availability.
We implemented an extra-program, called atsGenerator, to decomposition rules 2 (for UBC constraints), 4 and 5 (for LBC
simplify the definition of the transaction requirements (ATS). constraints). The rejection probability of a feasible solution by
The program takes a hierarchical model as input parameter the decomposition procedure is low and smaller than 0.05.
and provides a valid ATS. The validity of the ATS is ensured
using the rules described in Subsection IV-A1. For practical C. Comparison with the approaches [8] and [7]
purposes, we set the penalty factor α c of each QoS constraint The second conducted experiment concerns the comparison
to 1 in the optimization function (OF). For all experiments, of our CSC algorithm (denoted as method #1) with the
the number of candidate Web services per simple functional approaches [8] and [7] (denoted as method #2) in terms of
capability (represented by a leaf node in Ctree) is fixed to 200. efficiency. In what follows, we start by briefly describing of
the method #2. Then, we present the comparison results.
B. Evaluating the effectiveness of the decomposition proce- 1) Short overview of the method #2: In [7], [8], a transac-
dure tional approach for the construction of composite services is
The first experiment of the empirical studies concerns proposed. Such approach integrates the transactional require-
the evaluation of the decomposition procedure in terms of ments (defined by designers using the ATS concept) while

1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017 11

defining service composition. However, the efficiency of the
composition and customers satisfaction are not guaranteed
since the QoS properties are completely ignored.
2) Comparison results: The results of the second experi-
ment are shown in Figure 4. These results clearly show the
benefits of integrating QoS properties and their related require-
ments in the services composition building process. While
being reliable, the generated composite services using method
#2 are not efficient. This is justified by the fact that there is
no real guarantee to ensure an efficient composition without
considering the requested QoS requirements. As reported, our
CSC algorithm is able to construct a reliable and efficient
composite service.
proposed by the methods #2 and #3 are highly complex global
optimization problems (NP-hard) [27], [28]. In [23], Barakat et
al. propose an approach (denoted as #4) for the Web services
selection and composition according to the QoS properties.
The approach defines the service composition model as a
directed graph, where the nodes denote functional capabilities
and the edges represent the dependencies between them. It
proposes an heuristic algorithm to select the appropriate Web
services satisfying a set of QoS constraints.

Fig. 5. Results of the comparison study of our CSC algorithm with the
approaches [26]–[28] and [23] in terms of reliability

2) Comparison results: The results of the experiment are

shown in Figure 5. These results show clearly the benefits of
Fig. 4. Results of the comparison study of our CSC algorithm with the
approaches [8] and [7]. integrating transactional properties and their related require-
ments (ATS) in the services composition building process.
For all the values of m, the service composition reliability
D. Comparison with the approaches [26]–[28] and [23] is never guaranteed using the methods #2, #3 and #4. These
results are justified by the fact that there is no real reliability
The third experiment of the empirical studies concerns the
guarantee without considering the transactional properties and
comparison of our CSC algorithm (denoted as method #1) with
requirements.
the approaches [26], [27], [28] and that proposed by [23]. Such
a comparison is done in terms of efficiency and reliability.
Being originally based on heuristics, the methods #2, #3 and
#4 are executed 50 times for each value of m and the average
values of reliability are finally reported. Before reporting the
evaluation results, we introduce brief overview of the methods
#2, #3 and #4.
1) Short overview of the methods [26]–[28] and [23]: In
[27] and [26], a new Web service composition method based
on global QoS constraint decomposition and QoS dynamic
prediction is proposed. The approach (denoted as method
#2) includes two critical phases. First, before service com-
position, global QoS constraints are decomposed into local
constraints using the genetic algorithm, and the problem of
Fig. 6. Results of the comparison study of our CSC algorithm with the
Web service dynamic composition is transformed into a local approaches [26]–[28] and [23] in terms of efficiency
optimization problem. Second, the optimal Web services are
selected according these local QoS constraints to execute a As reported in Figure 6, all the methods (#2, #3 and #4)
set of functional capabilities. The approach introduced in [28] are able to provide an efficient composite service when the
(denoted as method #3) is slightly similar to that presented m value is smaller than 30. From about 25 CFC (complex
in [27]. Hence, it consists in two main steps. First, the functional capabilities), the efficiency of the solutions identi-
global utility function is decomposed using algorithms into fied by the methods #2, #3 and #4 starts to slightly decrease.
a set of local utility functions using a genetic algorithm. The This behavior is justified by the NP-harness issue of the
global utility function computes the mean value of all existing services composition problem and the decomposition process.
composite services QoS. Second, an optimal local selection The decomposition processes are global optimization problems
of Web services is performed. The decomposition processes where the goal is to find the optimal local constraints/utility

1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017 12

functions. Such optimization problems are proved in [27], [28]

as NP-hard.

E. Comparison with the approach [6]

In the literature, there are different transactional and QoS-
aware related approaches [6], [15], [20], [29], [30]. Due to
the lack of space, we have chosen to compare CSC algorithm
(denoted as method #1) only with our previous approach [6],
[15] (denoted as method #2) in terms of computation time
and efficiency. This choice is justified by the fact that such
approach is the most closely one of our CSC algorithm.
Moreover, both the approach and CSC algorithm integrate
Fig. 8. Results of the comparison study of our CSC algorithm with the
the transaction reliability and the efficiency requirements. The approach [6] in terms of computation times.
other related transactions and QoS-aware approaches do not
consider these two requirements types.
TABLE IV
C LASSIFICATION OF THE EXISTING SERVICE COMPOSITION APPROACHES

Categories Composition Adaptation

Transaction-based [7], [8], [14] [32], [33]
QoS-based [23], [25]–[28], [31], [34]–[37] [22], [23], [38]–[41]
TQoS-based [6], [15], [20], [29], [30] [6]

Fig. 7. Results of the comparison study of our CSC algorithm with the
approach [6] in terms of efficiency.
Figure 7 shows the benefits of the proposed CSC algorithm
in comparison with our previous approach [6] in terms of
efficiency. As reported, the method #2 is able to provide an
efficient composite service when the m value is smaller than
30. However, such an efficiency is slightly decreased when the
value of m becomes larger than 30. This behavior confirms
what claimed in [31]. This behavior is justified by the NP-
hardness issue of the CSC problem. For complex instance
of problem, the genetic algorithms (like that used in [6])
try to generate a Pareto-optimal (an approximate) solution at
reasonable computation times. Hence, when the value of m
is closer to 30, the computation time of method #2 starts to
remarkably increase (see Figure 8). We have remarked that
the computation time of our CSC algorithm is linear with the
CFC number (m) of the capability tree (Ctree).
VII. R ELATED WORK
The service composition problem is still an active research
topic. Hence, a large number of approaches have been intro-
duced. As illustrated in Table IV, these approaches can be
classified into three main categories:
1) Transaction-aware approaches
2) QoS-aware approaches
3) Transaction and QoS (TQoS)-aware approaches
The following subsections give an overview of these ap-
proaches with an outline of their main shortcomings based
on the conducted evaluations.
A. Transaction-aware approaches
The existing transaction-aware approaches focus on either
constructing new composite services, or adapting others based
on the transactional properties. Indeed, the transactional ap-
proach [8], [14] allows the definition of composite services.
It uses the ATS concept as a means to ensure execution
reliability. The work presented in [7] is an extension of
the transactional approach introduced in [8], [14]. The ex-
tensions are limited to automating the process of selecting
Web services. The transaction-aware approach [32] proposes
a complete services adaptation framework. This framework is
based on the transaction model, FENECIA that is introduced
by [33]. It combines the exceptions handling and transaction
management mechanisms.
According to the conducted evaluation in Section VI, the
main weak point of the transaction-aware approaches is their
inability to ensure an efficient composite service. Without
integrating the transactional properties in the composition or
in the adaptation process, there is no real efficiency guarantee.
B. QoS-aware approaches
This class of approaches allows to construct or adapt
composite services according to the QoS properties. Jatoth
et al. [42] investigate the existing research studies on the
QoS-aware service composition topic. They propose a sys-
tematic review of the proposed QoS-aware approaches, while
highlighting their main weak points. Indeed, [31] proposes
a global QoS-aware approach for the Web services selection
and composition using genetic algorithms. Such an approach
is implemented and compared with other heuristic algorithms
introduced in [34]. In [35], the authors introduce an ap-
proach that combines the global and local optimization for
the selection of the appropriate Web services according to
their QoS properties. A GRASP with Path Relinking based

1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017
method for QoS-aware web services composition is proposed
in [37]. Such a method uses a metaheuristic algorithm to
perform the QoS-aware web service selection and composition
at runtime. The approach presented in [43] adopts a particle
swarm optimization algorithm for the selection of the most
relevant service according to users’ QoS requirements.
Other approaches introduce a decomposition process of the
global QoS constraints to facilitate the Web services selection
and composition. In [26]–[28], the authors propose a hybrid
approach that combines the constraints decomposition and
the local selection. As expected, the performance of such an
approach, in terms of efficiency, is similar to [31] and [34].
These results are justified by the fact that the decomposition
process of global constraints is NP-hard like the service com-
position problem [26], [27]. This NP-hardness issue justifies
the adoption of genetic algorithms in [27] and [26]. In addition,
the decomposition method proposed by [28] is based mainly
on the use of the mean value of Web services QoS properties.
Such a method does not distinguish between the positive
and negative properties. In contrast to [26], [28] and [27],
our recursive decomposition procedure is able to solve the
NP-hardness issue of the service composition with higher
recall and precision levels. Indeed, based on the results of the
conducted experiments, our CSC algorithm can generate, in a
timely fashion, a composite service that is not only reliable, but
also efficient. More recently, the approach [25] has introduced
a set of rules to decompose the global constraints into locals
ones. While being practical and interesting, these rules are
simple and cannot be applied to decompose UBC and LBC
global constraints, especially those defined for the reliability
and the availability properties, etc.
In [36], Alrifai et al. propose a skyline-based approach to
select services for composition according to the QoS properties
and SLA policy. The purpose behind the use of the skyline
is to reduce the number of candidate services. The authors
of [23] propose an adaptive QoS-aware approach for Web
service composition. The approach can be used to both define
composite services and repair them in case of dynamic changes
problems. The works proposed by [22], [38]–[40] and [41]
have introduced composite Web service adaptation processes
with QoS awareness.
The major shortcoming of the QoS-aware approaches con-
cerns the guarantee of composite services reliability. Indeed,
according to the conducted empirical evaluation (see Section
VI), integrating the transactional properties is very useful as it
allows to ensure a reliable execution of the composite services.
Hence, without such an integration there is no real reliability
guarantee.
C. TQoS-aware approaches
The TQoS-aware approaches are extensions to those based
on QoS with the consideration of the Web service transactional
aspects. Indeed, the authors of [20] introduce a new Web
services selection and composition algorithm. This algorithm
takes into account the transactional and QoS properties of Web
services. In [29] and [30], an extension to [20] that considers
global QoS constraints is proposed. However, these three
1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
13
TQoS-aware approaches are not flexible enough as they do
not allow the industry designers to specify their requirements
in terms of fault recovery strategies. Moreover, they try to
apply the conventional atomicity property in Web service
composition. Such an enforcement consists in ensuring that
either all of the components are complete, or none of them
is. As claimed in [8], this is not practical and can even be
considered infeasible due to the richness and the complexity
of the Web service composition structure. According to our
motivating example, the online tourist service can successfully
terminate its execution with the failure of the services fulfilling
the capabilities f4 and f6. The aforementioned shortcomings
were solved in [15] and [6] using the ATS concept. Indeed,
the genetic-based adaptive approach [6] is an extension to [15]
with the dynamic change evaluation.
VIII. C ONCLUSION
In this work, we first developed a hierarchical model for
composite services. Based on this model, we developed a
recursive procedure for the automatic computation of the
transactional reliability and the QoS of composite services.
Second, we proposed a new concept, called REL, to offer
more flexibility to the customers to specify their needs in
terms of QoS. Third, we developed a new CSC algorithm
for the construction and adaptation of composite services
based on transactions and QoS requirements. The originality
of such an algorithm consists in a new recursive global QoS
constraint decomposition procedure. Such a procedure allows
to effectively solve the NP-hardness issue of the service
composition and avoid using heuristic-based methods. Finally,
we proposed empirical studies to evaluate the benefits of our
CSC algorithm. The conducted evaluations show that our CSC
algorithm is able to generate, in a timely fashion, reliable
and efficient composite services according to designers’ and
customers’ needs.
We are currently working on extending our algorithm for
Cloud-based Web services through the consideration of several
aspects such as network QoS (throughput, latency, etc.), users’
mobility and Cloud resources consumption.
R EFERENCES
[1] G. Alonso, F. Casati, H. Kuno, and V. Machiraju, “Web services,” in
Web Services. Springer, 2004, pp. 123–149.
[2] H. Becha and D. Amyot, “Non-functional properties in service oriented
architecture–a consumers perspective,” JOURNAL OF SOFTWARE,
vol. 7, no. 3, p. 575, 2012.
[3] E. Al-Masri and Q. H. Mahmoud, “Investigating web services on the
world wide web,” in Proceedings of the 17th international conference
on World Wide Web. ACM, 2008, pp. 795–804.
[4] S. Dustdar and W. Schreiner, “A survey on web services composition,”
International journal of web and grid services, vol. 1, no. 1, pp. 1–30,
2005.
[5] Q. Z. Sheng, X. Qiao, A. V. Vasilakos, C. Szabo, S. Bourne, and X. Xu,
“Web services composition: A decades overview,” Information Sciences,
vol. 280, pp. 218–238, 2014.
[6] M. Graiet, I. Abbassi, M. Kmimech, and W. Gaaloul, “A genetic-based
adaptive approach for reliable and efficient service composition,” IEEE
Systems Journal, 2016.
[7] F. Montagut, R. Molva, and S. T. Golega, “Automating the composition
of transactional web services,” International Journal of Web Services
Research, vol. 5, no. 1, p. 24, 2008.
This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI 10.1109/TNSM.2017.2785360, IEEE
Transactions on Network and Service Management
IEEE TRANSACTIONS ON NETWORK AND SERVICE MANAGEMENT, VOL. XX, NO. YY, MONTH 2017
[8] S. Bhiri, W. Gaaloul, C. Godart, O. Perrin, M. Zaremba, and W. Der-
guech, “Ensuring customised transactional reliability of composite ser-
vices,” in Innovations in Database Design, Web Applications, and
Information Systems Management. IGI Global, 2013, pp. 203–232.
[9] H. Ludwig, A. Keller, A. Dan, R. P. King, and R. Franck, “Web service
level agreement (wsla) language specification,” IBM Corporation, pp.
815–824, 2003.
[10] D. D. Lamanna, J. Skene, and W. Emmerich, “Slang: A language for
service level agreements.” IEEE Computer Society Press, 2003.
[11] C. Zeginis, “Monitoring the qos of web services using slas–computing
metrics for composed services,” Master’s Thesis, University of Crete
Computer Science Department, Heraklion, 2009.
[12] M. Eichberg, K. Klose, R. Mitschke, and M. Mezini, Component
Composition Using Feature Models. Berlin, Heidelberg: Springer Berlin
Heidelberg, 2010, pp. 200–215.
[13] M. Rusinkiewicz and A. P. Sheth, “Specification and execution of
transactional workflows.” Modern database systems, vol. 1995, pp. 592–
620, 1995.
[14] S. Bhiri, O. Perrin, and C. Godart, “Ensuring required failure atomicity
of composite web services,” in Proceedings of the 14th international
conference on World Wide Web. ACM, 2005, pp. 138–147.
[15] I. Abbassi, M. Graiet, W. Gaaloul, and N. B. Hadj-Alouane, “Genetic-
based approach for ats and sla-aware web services composition,” in
International Conference on Web Information Systems Engineering.
Springer, 2015, pp. 369–383.
[16] M. C. Jaeger, G. Rojec-Goldmann, and G. Muhl, “Qos aggregation
for web service composition using workflow patterns,” in Proceedings.
Eighth IEEE International Enterprise Distributed Object Computing
Conference, 2004. EDOC 2004., 2004, pp. 149–159.
[17] F. Moscato, N. Mazzocca, V. Vittorini, G. D. Lorenzo, P. Mosca, and
M. Magaldi, “Workflow pattern analysis in web services orchestration:
The BPEL4WS example,” in High Performance Computing and Commu-
nications, First International Conference, HPCC 2005, Sorrento, Italy,
September 21-23, 2005, Proceedings, 2005, pp. 395–400.
[18] P. Wohed, W. Aalst, M. Dumas, and A. Hofstede, “Pattern-based analysis
of bpel4ws,” 2002.
[19] C. H. Papadimitriou, Computational complexity. John Wiley and Sons
Ltd., 2003.
[20] J. El Hadad, M. Manouvrier, and M. Rukoz, “Tqos: Transactional and
qos-aware selection algorithm for automatic web service composition,”
IEEE Transactions on Services Computing, vol. 3, no. 1, pp. 73–85,
2010.
[21] N. B. Mabrouk, S. Beauche, E. Kuznetsova, N. Georgantas, and V. Is-
sarny, “Qos-aware service composition in dynamic service oriented
environments,” in ACM/IFIP/USENIX International Conference on Dis-
tributed Systems Platforms and Open Distributed Processing. Springer,
2009, pp. 123–142.
[22] B. Chen, X. Peng, Y. Yu, and W. Zhao, “Requirements-driven self-
optimization of composite services using feedback control,” IEEE Trans-
actions on Services Computing, vol. 8, no. 1, pp. 107–120, 2015.
[23] L. Barakat, S. Miles, and M. Luck, “Adaptive composition in dynamic
service environments,” Future Generation Computer Systems, 2016.
[24] S. Mahdavi-Hezavehi, M. Galster, and P. Avgeriou, “Variability in qual-
ity attributes of service-based software systems: A systematic literature
review,” Information and Software Technology, vol. 55, no. 2, pp. 320–
343, 2013.
[25] C. Surianarayanan, G. Ganapathy, and M. S. Ramasamy, “An approach
for selecting best available services through a new method of decom-
posing qos constraints,” Service Oriented Computing and Applications,
vol. 9, no. 2, pp. 107–138, 2015.
[26] Z.-Z. Liu, X. Xue, J.-q. Shen, and W.-R. Li, “Web service dynamic
composition based on decomposition of global qos constraints,” The
International Journal of Advanced Manufacturing Technology, vol. 69,
no. 9-12, pp. 2247–2260, 2013.
[27] Z. Z. Liu, Z. P. Jia, X. Xue, and J. Y. An, “Reliable web service
composition based on qos dynamic prediction,” Soft Computing, vol. 19,
no. 5, pp. 1409–1425, 2015.
[28] S. X. Sun and J. Zhao, “A decomposition-based approach for service
composition with global qos guarantees,” Information Sciences, vol. 199,
pp. 138–153, 2012.
[29] Q. Wu and Q. Zhu, “Transactional and qos-aware dynamic service
composition based on ant colony optimization,” Future Generation
Computer Systems, vol. 29, no. 5, pp. 1112–1119, 2013.
[30] V. Gabrel, M. Manouvrier, I. Megdiche, and C. Murat, “A new 0–1 linear
program for qos and transactional-aware web service composition,” in
Computers and Communications (ISCC), 2012 IEEE Symposium on.
IEEE, 2012, pp. 000 845–000 850.
1932-4537 (c) 2017 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission. See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
14
[31] G. Canfora, M. Di Penta, R. Esposito, and M. L. Villani, “An approach
for qos-aware service composition based on genetic algorithms,” in
Proceedings of the 7th annual conference on Genetic and evolutionary
computation. ACM, 2005, pp. 1069–1075.
[32] A. Liu, Q. Li, L. Huang, and M. Xiao, “Facts: A framework for fault-
tolerant composition of transactional web services,” IEEE Transactions
on Services Computing, vol. 3, no. 1, pp. 46–59, 2010.
[33] N. Ben Lakhal, T. Kobayashi, and H. Yokota, “Fenecia: failure endurable
nested-transaction based execution of composite web services with in-
corporated state analysis,” The VLDB JournalThe International Journal
on Very Large Data Bases, vol. 18, no. 1, pp. 1–56, 2009.
[34] D. Comes, H. Baraki, R. Reichle, M. Zapf, and K. Geihs, “Heuristic
approaches for qos-based service selection,” in International Conference
on Service-Oriented Computing. Springer, 2010, pp. 441–455.
[35] M. Alrifai, T. Risse, and W. Nejdl, “A hybrid approach for efficient web
service composition with end-to-end qos constraints,” ACM Transactions
on the Web (TWEB), vol. 6, no. 2, p. 7, 2012.
[36] M. Alrifai, D. Skoutas, and T. Risse, “Selecting skyline services for qos-
based web service composition,” in Proceedings of the 19th international
conference on World wide web. ACM, 2010, pp. 11–20.
[37] J. A. Parejo, S. Segura, P. Fernandez, and A. Ruiz-Cortés, “Qos-aware
web services composition using grasp with path relinking,” Expert
Systems with Applications, vol. 41, no. 9, pp. 4211–4223, 2014.
[38] K.-J. Lin, J. Zhang, and Y. Zhai, “An efficient approach for service
process reconfiguration in soa with end-to-end qos constraints,” in
Commerce and Enterprise Computing, 2009. CEC’09. IEEE Conference
on. IEEE, 2009, pp. 146–153.
[39] Z. Zheng and M. R. Lyu, “An adaptive qos-aware fault tolerance strategy
for web services,” Empirical Software Engineering, vol. 15, no. 4, pp.
323–345, 2010.
[40] J. Li, D. Ma, X. Mei, H. Sun, and Z. Zheng, “Adaptive qos-aware
service process reconfiguration,” in Services Computing (SCC), 2011
IEEE International Conference on. IEEE, 2011, pp. 282–289.
[41] O. Tibermacine, C. Tibermacine, and F. Cherif, “A process to identify
relevant substitutes for healing failed ws-* orchestrations,” Journal of
Systems and Software, vol. 104, pp. 1–16, 2015.
[42] C. Jatoth, G. Gangadharan, and R. Buyya, “Computational intelligence
based qos-aware web service composition: A systematic literature re-
view,” IEEE Transactions on Services Computing, vol. 10, no. 3, pp.
475–492, 2017.
[43] T. Zhang, “Qos-aware web service selection based on particle swarm
optimization.” JNW, vol. 9, no. 3, pp. 565–570, 2014.
ABBASSI Imed is an associate in High School of
Computer Science of Mednine, Gabes University. He
received a diploma of the second cycle in Computer
Science with high distinction in 2010 and a master’s
degree in computer science in 2012 from the Faculty
of Sciences of Monastir. He is studying towards
a PhD degree in computer science at the National
Engineering School of Tunis. His research interests
include Service/cloud computing, service Reliabil-
ity/flexibility, formal modeling and verification.
GRAIET Mohamed is an associate professor in
High School of Computer Science and Mathemat-
ics, Monastir University. He is currently serving as
Department Head of Computer Science. He holds
a Ph.D. (2007) in software engineering from the
university of Joseph Fourier (Grenoble I), France.
His research interests include Service computing,
service Component Architecture (SCA), services Re-
liability/flexibility, and formal verification.