A MULTI-AGENT SELECTION OF MULTIPLE COMPOSITE WEB

SERVICES DRIVEN BY QOS

Fatma Siala and Khaled Ghedira

University of Tunis – SOIE, Tunis, Tunisia

Keywords:

QoS, Web service, Multi-agent system, Composition, Contract-net protocol, Combinations, Execution paths.

Abstract:

As the number of functionally similar Web Services from providers with different Quality of Service’s (QoS)

scores is increasing, a selection needs to be made to determine which services are to participate in a given

composite service. Moreover, QoS becomes one of the most important factors for Web Service selection.

Indeed, one of the main assets of service-orientation is a composition to develop higher level services, so-

called composite services, by re-using existing services. However, for a composition, we can have different

combinations and execution paths. Particularly, a composite service can generate different schemes that give

various QoS scores. We propose, in this paper, two frameworks. The ﬁrst framework deals with the selection

of composite Web services on the base of Multi-Agents negotiation. The objective of these agents is to ﬁnd

out the best Composite QoS (CQoS) based on Web services availability. The second framework improves the

ﬁrst one by supporting different combinations and execution paths.

The proposed Multi-Agents frameworks are compared to an existing approach in terms of execution time and

QoS’s score. Experiments have demonstrated that our frameworks provide reliable results in comparison with

the existing approach.

1 INTRODUCTION

Web service technology is greatly contributing to

change the landscape of today’s software engineering.

One of the most promising advantages of the service-

oriented paradigm is related to service run-time dis-

coveries and late binding mechanisms (Canfora et al.,

2008).

Web services are the basis of service-oriented soft-

ware, which is based on network, including simple

standards such as the Web Services Description Lan-

guage (WSDL), the Universal Description, Discov-

ery and Integration (UDDI) and the Simple Object

Access Protocol (SOAP). These standards can help

service publication, service location and use services

through Internet. WSDL is the standard language for

describing a Web service. UDDI is used to register

and search Web services. SOAP, as a transport layer,

is used to send messages between service users and

service providers

. XML is a language to support

these standards.

Indeed, one of the main assets of service’s ori-

entation is composition to develop higher level ser-

http://www.w3c.org/TR/wsdl

vices. A composite Web service is a collection of sin-

gle Web services that form a new complex service.

Based on a control ﬂow description of the composi-

tion, suitable task candidates must be discovered and

from these candidates, the most suitable must be se-

lected. The ﬂow description with an assignment of

concrete services can be used to parametrise an exe-

cution engine to perform the composition (Jaeger and

Ladner, 2006).

As the most requests concern composite services,

the QoS-based Composition (CQoS) selection be-

comes very important. It is related to the quality of

any elementary service. Notably, a system composed

of services that ensures the individual QoS that should

achieve optimal CQoS is always a problem during the

search. Issues related to the guaranteed QoS com-

positions are as important as the issues related to the

functional services. The Web services QoS focus on

non-functional attributes identiﬁed by the W3C

. The

elements of quality include price, availability, relia-

bility, reputation and so on.

Moreover, a composite service can be represented

by a statechart which has multiple execution paths

http://www.w3c.or.kr/kr-ofﬁce/TR/2003/ws-qos/

675

Siala F. and Ghédira K..

A MULTI-AGENT SELECTION OF MULTIPLE COMPOSITE WEB SERVICES DRIVEN BY QOS.

DOI: 10.5220/0003555306750684

In Proceedings of the 1st International Conference on Cloud Computing and Services Science (MAS-2011), pages 675-684

ISBN: 978-989-8425-52-2

 2011 SCITEPRESS (Science and Technology Publications, Lda.)

when containing conditional branchings. Each execu-

tion path represents a sequence of tasks to complete a

composite service execution. Furthermore, for a com-

posite Web service, we notice that we can have differ-

ent possible combinations.

Our work aims at advancing the current state of

the art in technologies for Web service composition

by ﬁrst, taking into account the user’s preferences,

second, by using agents to negotiate the QoS value

and dynamically select providers for various services

in the composition (based on availability). Finally, by

proposing a framework that supports different execu-

tion paths and combinations. Our contributions are re-

vealed when negotiating only with available Web ser-

vices providers that give a better Central Processing

Unit (CPU) time and by supporting different execu-

tion paths and combinations for a composition. The

combination concept has never been addressed by any

approach.

The structure of this paper is as follows: The

coming section brieﬂy introduces the main concepts

used in our work. Section 3 presents the major re-

lated works in the area of Web service composition

based on QoS. Section 4 proposes two frameworks

prototypes, an initial framework and its amelioration

for taking into account different execution paths and

combinations in a composition. Section 5 explains

the implementation of these frameworks using a case

study. Accordingly, section 6 presents the experimen-

tation results. After that, the approach is discussed in

section 7 by presenting existing approach limitations

and detailing our contributions and the difference be-

tween the two proposed frameworks. Finally, we con-

clude the whole paper.

2 MAIN CONCEPTS

In this section, we deﬁne three concepts used in the re-

mainder of the paper: execution path, composite Web

service and Web service combination.

To simplify the discussion, we initially assume

that all the statecharts that we deal with are acyclic.

If a statechart contains cycles, a technique for unfold-

ing it into an acyclic statechart needs to be applied be-

forehand detailed by (Zeng et al., 2004). We present

in Fig. 1 an example of a statechart with AND and

OR states.

Figure 1: Example of a statechart.

2.1 Execution Path

If a statechart contains conditional branchings, it has

multiple execution paths. Each execution path rep-

resents a sequence of tasks to complete a composite

service execution. Fig. 2 gives an example of a state-

chart’s execution paths. In this example, since there is

one conditional branching after service S

, there are

three paths, called EP1, EP2 and EP3 respectively. In

the execution path EP1, service S

is executed after

service S

while in the execution path EP2, service

is executed after service S

and in the execution

path EP3, service S

is executed after service S

Figure 2: Execution paths representation of Fig 1 statechart.

2.2 Composite Web Service

The services composition can be deﬁned as ”the pro-

cess of combining existing services to form new ser-

vices”. These assembled Web services will certainly

play a greater role for communication among applica-

tions. In particular, if non of the services are able to

respond to a request from a user, it will be possible to

combine existing Web services to perform this task.

As shown in Fig. 3, a service composition con-

sists normally of some services linked together, each

of them may be provided by more than one supplier.

For a particular service, many providers may offer

the same functionality but offer different QoS. We as-

sume in Fig.1 that a composite service is composed on

n services and each service S

may be provided from

p providers S

to S

. Let n = 3 and p = 5 (as an ex-

ample), to supply the composite service, we need ser-

vices S

, S

and S

in the composition. In addition, S

may be afforded by service providers S

1.1

, S

1.2

, S

1.3

1.4

or S

1.5

CLOSER 2011 - International Conference on Cloud Computing and Services Science

676

Figure 3: Web service composition.

2.3 Web Service Combination

For a composite Web service, we notice that we can

have different possible combinations. As an exam-

ple, when a user requests a composite Web service,

the same result service can be provided from differ-

ent web services combinations (ﬁg. 1 and ﬁg. 4).

The user will not be aware if the Web service S

executed after or before Web services S

and S

The two combinations give the same result but not the

same QoS.

Figure 4: Example of a combination.

3 RELATED WORKS

Several studies have been made to the services

composition taking into account QoS requirements

(Brandic et al., 2008) (Mukhija et al., 2007) (Kona

et al., 2009). In this section, we review selected works

based on their relevance for our approach.

(Zeng et al., 2004) have presented a solution for

the composition problem by analyzing multiple exe-

cution paths of a composite service which are spec-

iﬁed using UML (Uniﬁed Modeling Language) stat-

echarts. They have modeled the composition prob-

lem using different approaches, including a local op-

timization approach and global planning approach us-

ing linear programming.

(Guan et al., 2006) are the ﬁrst who propose

a framework for QoS-guided service compositions

which uses constraint hierarchies as a formalism for

specifying QoS. They use a branch and bound algo-

rithm that is only capable of solving sequential com-

positions. The authors do not present any empiri-

cal evaluation to demonstrate the optimization perfor-

mance of their approach.

(Rosenberg et al., 2009) have used constraint pro-

gramming and integer programming approach for op-

timizing QoS by leveraging constraints hierarchies as

a formalism to represent user constraints (speciﬁed

with a Domain-Speciﬁc Language) of different im-

portances.

(Canfora et al., 2008) have proposed an approach

based on genetic algorithms. To determine the opti-

mal set of concretizations, the approach needs to es-

timate the composite service QoS. This is done using

some aggregation formulas.

(Hong and Hu, 2009) have used an ordinary util-

ity function as a numerical scale of ordering local

services and a multi-dimension QoS based local ser-

vice selection model is proposed to provide important

grounds to choose a superior service and shift an in-

ferior one. Secondly, subjective weight mode, objec-

tive weight mode, and subject-objective weight mode

are constructed to determine the weight coefﬁcient of

each QoS criterion, and to show the users’ partiality

and the service quality’s objectivity.

(Alrifai and Risse, 2009) have employed Mixed

Integer Programming (MIP) to ﬁnd the optimal de-

composition of global QoS constraints into local con-

straints. They have used distributed local selection to

ﬁnd the best web services that satisfy these local con-

straints.

(Yan et al., 2007) have presented a framework in

which the service consumer is represented by a set

of agents who negotiate QoS constraints speciﬁed us-

ing SLA (Service Level Agreement), with the service

providers for various services in the composition ap-

plying the Contract-Net protocol. Their idea of using

Multi-Agents System and the Contract-Net protocol

is in line with the work presented in this paper. How-

ever, the authors do not deal with the the Web dy-

namism (the availability concept) so their approach

takes a large CPU time. Moreover, their framework

does not support the different execution paths and

combinations.

The majority of these approaches does not take

into account that for a composite service we can have

an execution plan that generates different execution

paths. These approaches deal only with the optimiza-

tion problem itself (ﬁnding the best CQoS) without

giving prominence for this aspect. Some approaches

deal with this aspect but repeating each time the gen-

eration of all the elementary Web services. More-

over, all these approaches do not take into consider-

ation that for a composite Web service we can have

different combinations. This concept has never been

addressed by any approach. By using Multi-Agents

A MULTI-AGENT SELECTION OF MULTIPLE COMPOSITE WEB SERVICES DRIVEN BY QOS

677

System, we generate all the execution paths and com-

binations in parallel and select the best execution path

or combination, so we gain in terms of CPU time.

We also take into consideration the importance of

the Web services’ availability since the Web is a dy-

namic environment. By considering only available

Web services we also improve the CPU time. Our

approach allows to ﬁnd the best CQoS by consider-

ing different execution paths and combinations and

by also taking into account the dynamical aspect of

the Web (the web service availability changes) which

directly inﬂuences the CPU time.

4 THE PROPOSAL

FRAMEWORKS

The ﬁrst step towards autonomously establishing QoS

value for a service composition is to have a support-

ing framework. This framework should be able to ad-

dress the special requirements for establishing QoS

value for a service composition. For the composition

process, we use (Lajmi et al., 2006) technique.

Our goal is to propose an approach to the Web

services composition that guarantees non functional

properties (QoS). This approach must also support

different execution paths and combinations. We

present, in the following, two frameworks. The ﬁrst

framework allows to select the best elementary Web

services in terms of QoS based on Web services avail-

ability. The second framework offers all ﬁrst frame-

work’s functionalities but also supports different ex-

ecution paths and combinations. Several motivations

lead to use Multi-Agent Systems (MAS) (Barbuceanu

and Fox, 1996). In fact, a Web service is passive until

it is invoked, have only a knowledge of himself and is

not adaptable and is not able to beneﬁt of new capa-

bilities of the environment (Charif et al., 2010).

We propose to represent each service by an agent.

In the MAS ﬁeld, negotiation is a core component

of agents interactions. Indeed, since agents are au-

tonomous, there is no imposed solution in advance,

but agents must reach solutions dynamically while

solving problems. The basic assumption of this ap-

proach is that each elementary Web service has an

agent responsible to it. The objective of these agents

is to ﬁnd out the best CQoS. They aware available

providers also represented with agents.

In this context, we propose two global frame-

works. The ﬁrst one optimizes the QoS criteria for a

composite service provision. The second framework

improves the ﬁrst one by considering different execu-

tion paths and combinations for a given statechart.

4.1 The First Framework

To better explain our approach, we present in Fig 5

the ﬁrst framework associated to Fig 3. This frame-

work consists of an Interface Agent (IA) and a set of

Negotiator Agents (NAs) that negotiate with a set of

Web Service Agents (WSAs).

The IA associates an NA for each elementary ser-

vice in the composition. These NAs negotiate via

the Contract-Net (CNET) protocol with WSAs (the

providers) to ﬁnd the best elementary Web service and

send the response to the IA which evaluates the results

and either conﬁrms the acceptance or repeat the nego-

tiation.

Figure 5: The First Framework.

4.1.1 The Interface Agent

The Interface Agent (IA) represents the interface that

allows the user to access the framework for specify

the desired service and QoS criteria. In fact, the user

can specify each criterion with a weight since differ-

ent users may have different requirements and prefer-

ences regarding QoS. For example, a user may require

to minimize the execution time, while another user

may give more importance to the price than to the ex-

ecution time. The selection process is based on the

weight assigned by the user to each criterion. The IA

computes the CQoS score using a formula proposed

by (Zeng et al., 2004). The IA will then, provide the

expected service with the required QoS criteria.

We should note that the system can allow a user

to deﬁne constraints expressed using a simple expres-

sion language. Examples of constraints that can be

expressed include duration constraints and price con-

straints.

4.1.2 The Negotiator Agent

A Negotiator Agent (NA) is responsible of a Web ser-

vices set offering the same functionality. This agent

is in charge of negotiating with providers for a service

from the composition in order to optimize the QoS.

We use a variant of the CNET protocol, the directed

CLOSER 2011 - International Conference on Cloud Computing and Services Science

678

award where the critical information which must be

aware by the NA is the availability. So, the NA ac-

quaintances are the available Web service providers.

For a negotiation, the NA must consult its list con-

taining available Web services.

4.1.3 The Web Service Agent

A Service Level Agreements (SLA) deﬁnes the terms

and conditions of service quality that a Web service

delivers to service requesters. The major constituent

of an SLA is the QoS information. There are a num-

ber of criteria (e.g., execution time, availability) that

contribute to a QoS in an SLA. Web service providers

publish QoS information in SLAs.

Each Web Service Agent (WSA) represents a Web

service. This Web service belongs to a Web services

class where an NA is responsible. For example, a

travel service provider may specify that it supports the

Trip-planning service and belongs to the service class

FlightTicketBooking. Service class describes the ca-

pabilities of Web services and how to access them.

The NA has a list that he consult whenever he be-

gins a negotiation. In this list there is the available

WSAs. By this method, we also take into account the

failure cases.

We note that in Fig 5, there is unavailable Web

services represented by agents that will not negotiate

with the NA.

4.2 The Negotiation

4.2.1 Negotiation Protocol

The negotiation protocol is the way and manner the

negotiating parties interact and exchange information.

It includes the way in which the offers and messages

are sent to opponents. There are various negotia-

tion protocols available in the research community.

In this paper, we propose to use the CNET Protocol,

named directed award where the manager must have a

table of acquaintances that contains knowledge about

other agents (eg, skills, knowledge, value judgments

about these agents). In this protocol, one agent (the

initiator) takes the role of manager which wishes to

have a task performed by the other agents (the partic-

ipants) and further wishes to optimize a function that

characterizes this task. We use the function proposed

by (Zeng et al., 2004). For a given task, any number

of the participants may respond with a proposal, the

rest must refuse.

4.2.2 Negotiation Coordination

The IA coordinates multiple negotiations for various

services in the composition. The purpose of the co-

ordination is to ensure that the results of these multi-

ple negotiation can collectively fulﬁll the end-to-end

QoS. The ﬁrst task that the IA performs is to attribute

a Web service with its QoS weights to the NAs. The

second task that the IA performs is to conﬁrm nego-

tiation results. As the extended negotiation protocol

suggests, when various NAs get the best deals, they

consult the IA for conﬁrmation. The IA evaluates the

results and either conﬁrms the acceptance or amends

the reserve values to continue the negotiation. The

QoS aggregation refers to the QoS model proposed in

(Zeng et al., 2004).

The NA sends a CFP message only to the avail-

able Web Service Agents. When The proposals and

counter proposals are then communicated iteratively

between the NAs and the service providers (WSAs),

following the standard FIPA protocol, until the best

deal is reached (i.e. the proposals offered by one

or more providers can satisfy the negotiation objec-

tives) or the timeout occurs. The NA block the se-

lected WSA. At this time, the best deal is sent to the

IA. If the overall QoS requirements are satisﬁed, the

IA conﬁrms to each NA that the current deal is ac-

ceptable. Subsequently, the NA acknowledges the

acceptance of the proposal to the selected providers

(WSAs). When the user ﬁnish using Web services,

the IA inform the NA to unlock the selected WSA.

In the case that the overall QoS requirements are

not satisﬁed based on the current best deals, the user

should modify the requirements and the IA amends

the reserve values for the NA to re-start negotiation.

Each corresponding NA then sends the modiﬁed CFP

to WSA and begins a new negotiation process

This research refers to the QoS model presented

in (Zeng et al., 2004) which consider ﬁve quality at-

tributes but other quality dimensions can be used in-

stead without any fundamental changes. The dimen-

sions are numbered from 1 to 5, with 1 = price, 2 = du-

ration, 3 = availability, 4 = success rate, and 5 = repu-

tation. Given a task t

in a composite service, there is

a set of candidate (elementary) Web services S

={s

1 j

2 j

, . . . , s

n j

} that can be used to execute this task. By

merging the quality vectors of all these candidate Web

services, a matrix Q = (Q

i, j

;1 ≤ i ≤ n, 1 ≤ j ≤ n).

In this case n=5. This matrix is built, in which

each row Q

corresponds to a Web service s

i j

while

each column corresponds to a quality dimension.

A Simple Additive Weighting (SAW) technique is

used to select an optimal Web service. There are two

phases in applying SAW:

A MULTI-AGENT SELECTION OF MULTIPLE COMPOSITE WEB SERVICES DRIVEN BY QOS

679

• Scaling Phase:

Some of the criteria could be negative, i.e., the higher

the value, the lower the quality. This includes criteria

such as execution time and execution price. Other cri-

teria are positive, i.e., the higher the value, the higher

the quality. For negative criteria, values are scaled ac-

cording to (1). For positive criteria, values are scaled

according to (2).

i, j







max

−Q

i, j

max

−Q

min

if Q

max

− Q

min

6= 0

1 if Q

max

− Q

min

6= 0

(1)

i, j







i, j

−Q

min

max

−Q

min

if Q

max

− Q

min

6= 0

1 if Q

max

− Q

min

6= 0

(2)

hspace-1cm In the above equations, Q

max

is the maxi-

mal value of a quality criteria in matrix Q, i.e., Q

max

Max(Q

i, j

), 1 ≤ i ≤ n.

While Q

min

is the minimal value of a quality crite-

ria in matrix Q, i.e.,

min

= Min(Q

i, j

), 1 ≤ i ≤ n.

By applying these two equations on Q, we obtain

a matrix V = (V

i, j

;1 ≤ i ≤ n, 1 ≤ j ≤ n),

in which each row Vj corresponds to a Web ser-

vice sij while each column corresponds to a quality

dimension.

• Weighting Phase :

The following formula is used to compute the overall

quality score for each Web service:

score(p

) =

∑

j=1

i j

∗W

) (3)

where W

∈ [0, 1] and

∑

j=1

= 1.

Wj represents the weight of criterion j. End users

express their preferences regarding QoS by providing

values for the weights W

For a given task, the NA will choose the Web ser-

vice which satisﬁes all the user preferences for that

task and which has the maximal score. If there are

several services with maximal score, one of them is

selected randomly. If no service satisﬁes the user

preferences for a given task, an execution exception

will be raised and the IA will propose the user to

change his preferences.

4.3 The Second Framework

We propose an improvement for the ﬁrst framework

to enable the support of different execution paths and

combinations (second framework represented in ﬁg

6). We add a new agent category, the Combination

Coordination Agent (CCA).

Figure 6: Second Framework.

First, the user specify the desired composite Web

service and the associated requirements. Then, The

IA charges each CCA for an execution path or com-

bination of the statechart, Second, the IA negotiates

via the CNET protocol for the best execution path.

Finally, the IA returns to the user the best Web ser-

vice composition. We explain in the following the

role or each agent. We explain the negotiation process

through an AUML protocol diagram (Fig 7). The ne-

gotiation between the other agents is like to the ﬁrst

framework.

Figure 7: Negotiation protocol success.

In the case that the overall QoS requirements are

not satisﬁed based on the current best deals, the user

modify the requirements and the IA amends the re-

serve values for the NA to re-start negotiation. Each

corresponding NA then sends the modiﬁed CFP to

WSA and begins a new negotiation process, as shown

in Fig 8).

CLOSER 2011 - International Conference on Cloud Computing and Services Science

680

Figure 8: Negotiation protocol failure.

4.3.1 The Interface Agent

The Interface Agent (IA) represents the interface that

allows the user to access the framework to specify

the desired service and QoS criteria. In fact, the user

can indicate each criterion with a weight since differ-

ent users may have different requirements and prefer-

ences regarding QoS. The IA charge each CCA for an

execution path or combination of the statechart and

will, thereafter, select using the CNET protocol the

best proposal from CCAs.

4.3.2 The Combination Coordinator Agent

The Combination Coordinator Agent (CCA) interacts

with the IA to receive an execution path or combi-

nation of the statechart for the service composition

and the user requirements. Each CCA is responsible

for an execution path or combination of a composi-

tion. This agent attributes a NA for each Web ser-

vices and computes the CQoS score using a formula

proposed by (Zeng et al., 2004) when it receives their

responses. Finally, the CCA negotiates with the IA

using the CNET protocol to provide its proposal.

4.3.3 The Negotiator Agent

A Negotiator Agent (NA) has the same role as in the

ﬁrst framework however, in this case, it negotiates

with the CCAs instead of the IA. The selected WSA

is blocked (reserved).

The Web Service Agent saves the same role as in

the ﬁrst framework. Once again, we note that in Fig

6, there are unavailable Web services represented by

agents that will not negotiate with the NA. The WSA

has the same role as in the ﬁrst framework.

When the user ﬁnishes using the Web services, the

IA inform the NA which should also inform the WSA

to unlock the WSA.

5 IMPLEMENTATION AND CASE

STUDY

To show the key ideas presented in this paper, a

prototype has been implemented for the proof-of-

concept purpose using the FIPA compliant JADE

Agent Framework

which is a middleware that im-

plements an agent platform and a development frame-

work. This framework supports agents’ negotiations

through an Agent Communication Language (ACL).

During the negotiation, the IA, the CCAs, the NAs

and the WSAs exchange a number of messages.

We explain our approach through a case study.

A simpliﬁed statechart specifying a scenario in the

tourism industry composite Web service is depicted

in Fig 1. In this scenario, a tourist who holds a mobile

device can request the full description of the route in-

formation from his/her current position to a selected

attraction. We have height different services, that will

be invoked, deﬁned as follows:

• A Phone Location Service(S

): to ﬁnd the cur-

rent position of the tourist.

• A Route Calculation Service (S

): to calculate

the route from the tourist’s position to the attrac-

tion.

• A Route Description Service(S

): to generate

and present graphical and textual description of

the route to the tourist.

• A Trafﬁc Service (S

): to present the trafﬁc of the

route from the tourist’s position to the attraction.

• A Car Service (S

): to generate the duration that

could be taken at this moment from the tourist’s

position to the attraction, if the tourist uses a car.

• A Bus Service (S

): to generate the duration that

could be taken at this moment from the tourist’s

position to the attraction, if the tourist uses a bus.

• A Metro Service (S

): to generate the dura-

tion that could be taken at this moment from the

tourist’s position to the attraction, if the tourist

uses a metro.

• A Metro Service (S

): to generate the cost that the

tourist should pay.

JADE (Java Agent Development Framework), Tele-

com Italia Lab, version available at: http://sharon.cselt.it/

projects/jade/

A MULTI-AGENT SELECTION OF MULTIPLE COMPOSITE WEB SERVICES DRIVEN BY QOS

681

In this example, after the service S

is completed, the

service S

is done in parallel with S

. After these

services are completed, the S

is triggered and either

, S

or S

is invoked. Finally, the service S

generated (Fig 1).

The tourist can also specify some QoS require-

ments when making his/her request. For example, the

tourist can request that the score of CQoS is delivered

with a value top then 70. Obviously, the tourist can

also require the QoS score for the elementary Web

services such S

, S

, etc.

The tourist should also indicate the weight asso-

ciated to each QoS attribute. Example of weights

values : price=0.15, duration=0.35, success rate=0.40

and reputation=0.10. These weights will be used for

the computation of the QoS score of each elementary

Web services using formula 3. If the user does not

specify weights, the system will consider a weight

value = 0.25 for each criterion.

So, each IA send at the same time a CFP to the

CCAs for an execution path or combination in the

statechart of the composition. In our case (Fig 2), we

have three execution paths. Each NA (height NAs) as-

sociated to an elementary Web service negotiates with

the available WSAs for one service in the composi-

tion. The WSAs randomly generate proposals (QoS

score) with the value between 10 and 100.

Each NA negotiates with providers simultane-

ously. The negotiation results for each service are

summarized in Table 1. After the reception of offers

from available WSAs, the height NAs select the best

offer, block the WSAs associated to the selected

Web services and return their best offers to the

CCAs. Each CCA (three CCAs) calculates its CQOS

score. Supposing that we have these results after the

negotiation, EP1= 65; EP2 = 84 and EP3=40. The

IA will choose the EP2 that has the best CQoS. The

whole process is simulated using the prototype.

The following results are conﬁrmed:

Metro Service (S

) : 66

Phone Location Service (S

) : 98

Metro Service (S

) : 80

Phone Location Service (S

) : 79

Route Calculation Service (S

) :87

Route Description Service (S

) : 73

Trafﬁc Service (S

) : 85

Bus Service (S

) :92

These results are associated to the best QoS of

each elementary Web service. Finally, the IA checks

if the best offers can jointly fulﬁll the user’s request

(the desired value of CQoS is 75) using a formula also

proposed by (Zeng et al., 2004).

When the tourist ﬁnishes using the Web service,

the IA informs the NA to unlock the selected (re-

served) WSA.

Table 1: QoS values (negotiation results) for each WSA.

S PL S RL S RD S T S C S B S M S P

1 65 46 80 25 35 73 85 92

2 33 39 40 48 28 54 77 45

3 66 24 50 38 66 49 76 22

4 40 45 26 79 32 46 80 21

5 22 98 44 75 87 24 37 64

6 EXPERIMENTATION

The ﬁrst series of tests were conducted to compare

the CPU time of our approach with the approach of

(Yan et al., 2007) to ﬁnd the best QoS for each ele-

mentary service and to perform the CQoS of the ﬁrst

framework.

In the experimentation, we have calculated the

CPU time of each approach (the Yan et al.’s approach

(Yan et al., 2007), the ﬁrst and the second frame-

works) by ﬁxing the number of elementary services

in a composition to 25 and varying the number of ser-

vice providers from 10 to 100 with steps of 10 for 50

execution paths. We have calculated the CPU dura-

tion 10 times for each case considering the average.

The results of these experiments are presented via a

chart (Fig. 9).

Figure 9: Comparison of CPU time.

These experiments show that by increasing the

number of Web services providers, the CPU time

also increases for each approach. The ﬁrst frame-

work takes a largely better CPU time than (Yan et al.,

2007)’s approach but the second framework takes a

little more time than (Yan et al., 2007)’s approach.

This result is evident since the Yan et al.’s approach

and the ﬁrst framework does not take into account dif-

ferent execution paths and combinations. Moreover,

the ﬁrst framework sends the CFP only to the avail-

able WSAs. On the other hand, the second framework

supports different execution paths and combinations

in a composition by also sending the CFP only to the

available WSAs.

We compare in Fig. 10 the quality score given by

CLOSER 2011 - International Conference on Cloud Computing and Services Science

682

each approach by also ﬁxing the number of elemen-

tary services in a composition to 25 and varying the

number of service providers from 10 to 100 with steps

of 10. obviously, the ﬁrst framework and the (Yan

et al., 2007)’s approach give the same quality score.

However, the second framework gives a largely better

CQoS score since it supports different execution paths

and combinations and chooses the best.

Figure 10: Comparison of QoS score.

By comparing only the CPU time or only the

CQoS score, we cannot conclude either the ﬁrst

framework is better than the second framework or

the contrary. That’s what we propose to use the for-

mula (4) which calculates a ratio between the time

and the quality. We show through Fig. 11, that the

ratio between the time and the QoS is largely lower

than 1. This explains that although the second frame-

work takes more CPU time than the ﬁrst framework,

it greatly improves the CQoS score.

Ratio =











−T

min

−T

min

−Q

min

−Q

min

if T

min

− T

min

6= 0

andQ

min

− Q

min

6= 0

1 if T

min

− T

min

= 0

andQ

min

− Q

min

= 0

(4)

In the above equation, T

is the average of CPU

time (we test 10 values in the experimentation for the

same case) taken by the ﬁrst framework, T

min

is the

minimum value of CPU time between the 10 values

taken in the experimentation for the ﬁrst framework.

is the average of CQoS taken by the ﬁrst frame-

work, Q

min

is the minimum value of CQoS between

the 10 values taken in the experimentation for the ﬁrst

framework. The same notions are respectively taken

for T

, T

min

, Q

and Q

min

to the second framework.

7 DISCUSSION

We compare our proposed frameworks with Yan et

al.’s one (Yan et al., 2007). To the best of our knowl-

edge, their work is the sole which uses agent technol-

Figure 11: Comparison of ratio between the ﬁrst and the

second frameworks.

ogy. (Maamar et al., 2005) have used MASs for Web

service composition but they don’t consider the QoS.

The (Yan et al., 2007) approach represents some

limitations, when the CNET protocol is used. The NA

has no knowledge about the agents. It will then send

the CFP to all service providers, and thus can cause

network congestion.

Our ﬁrst framework improves the work of (Yan

et al., 2007) in terms of CPU time. In fact, we de-

crease the number of negotiations (we alleviate the

network) by using a variant of the Contract-Net pro-

tocol, called the directed award and sending the CFP

only to the available Web Service Agents. This con-

tribution gains on CPU time.

On the other hand, our second framework im-

proves the work of (Yan et al., 2007) and the ﬁrst pro-

posed framework in terms of QoS by supporting mul-

tiple execution paths and combinations for a composi-

tion. By using formula (1), we have demonstrated that

the difference of CPU time is negligible compared to

the improvement of QoS. Supporting different com-

binations for a composition is a novel idea introduced

by our work. The greatest limitation of the second

framework is its lack of scalability. Therefore, we

are preparing a new scalable framework using Case

Based Reasoning.

The ﬁrst framework optimizes the QoS at the lo-

cal level and verify after that if it ensures the QoS at

the global level (CQoS). On the other side, the second

framework, by considering different execution paths

and combinations, has more chances to ensure the

QoS at the global level.

Note that our approach supports as more attributes

of QoS (price, duration, reputation, success rate,

availability, etc.) as we want.

A MULTI-AGENT SELECTION OF MULTIPLE COMPOSITE WEB SERVICES DRIVEN BY QOS

683

8 CONCLUSIONS

In service-oriented computing, adequate support for

the service consumers and the service providers to

achieve agreements on QoS values is highly de-

manded. This important issue becomes more complex

in the context of service composition provision, where

the service consumer needs to achieve a set of in-

terrelated agreements with various services providers

in order to collectively fulﬁll the end-to-end QoS re-

quirements. Moreover, for a composite Web service,

we notice that we can have different possible combi-

nations and multiple execution paths since it contains

conditional branchings.

This paper exploits the agent technology to ad-

dress this crucial issues. A ﬁrst framework is pro-

posed using agents that are able to negotiate with ser-

vice providers, in a coordinated way, to ensure end-

to-end QoS. Based on this framework, the negotiation

follows an extended FIPA protocol. So, agents can ex-

change meaningful messages with service providers

in a deﬁned order. A contract Net protocol vari-

ant, called the directed award based on Web services

providers availability is used. A second framework

is proposed to support different execution paths and

combinations for a composition.

Our approach advances the current state of the art

by taking into account the Web services availability

and supporting different execution paths and combi-

nations for a composition. The proposed framework

is not scalable since the number of combination or ex-

ecution paths can be exponential. In the future work,

we will propose a new scalable framework which im-

proves our second framework by using Case Based

Reasoning.

REFERENCES

Alrifai, M. and Risse, T. (2009). Combining global opti-

mization with local selection for efﬁcient qos-aware

service composition. In WWW, pages 881–890.

Barbuceanu, M. and Fox, M. S. (1996). The design of a co-

ordination language for multi-agent systems. In ATAL,

pages 341–355.

Brandic, I., Pllana, S., and Benkner, S. (2008). Speci-

ﬁcation, planning, and execution of qos-aware grid

workﬂows within the amadeus environment. Con-

currency and Computation: Practice and Experience,

20(4):331–345.

Canfora, G., Penta, M. D., Esposito, R., and Villani, M. L.

(2008). A framework for qos-aware binding and re-

binding of composite web services. Journal of Sys-

tems and Software, 81(10):1754–1769.

Charif, Y., Stathis, K., and Mili, H. (2010). Towards antici-

patory service composition in ambient intelligence. In

NOTERE, pages 49–56.

Guan, Y., Ghose, A. K., and Lu, Z. (2006). Using con-

straint hierarchies to support qos-guided service com-

position. In ICWS, pages 743–752.

Hong, L. and Hu, J. (2009). A multi-dimension qos based

local service selection model for service composition.

JNW, 4(5):351–358.

Jaeger, M. C. and Ladner, H. (2006). A model for the aggre-

gation of qos in ws compositions involving redundant

services. JDIM, 4(1):44–49.

Kona, S., Bansal, A., Blake, M. B., Bleul, S., and Weise, T.

(2009). Wsc-2009: A quality of service-oriented web

services challenge. In CEC, pages 487–490.

Lajmi, S., Ghedira, C., Gh

edira, K., and Benslimane, D.

(2006). Wescocbr: How to compose web services via

case based reasoning. In ICEBE, pages 618–622.

Maamar, Z., Most

efaoui, S. K., and Yahyaoui, H. (2005).

Toward an agent-based and context-oriented approach

for web services composition - appendices. IEEE

Trans. Knowl. Data Eng., 17(5).

Mukhija, A., Dingwall-Smith, A., and Rosenblum, D. S.

(2007). Qos-aware service composition in dino. In

ECOWS, pages 3–12.

Rosenberg, F., Celikovic, P., Michlmayr, A., Leitner, P., and

Dustdar, S. (2009). An end-to-end approach for qos-

aware service composition. In EDOC, pages 151–160.

Smith, R. G. (1980). The contract net protocol: High-level

communication and control in a distributed problem

solver. IEEE Trans. Computers, 29(12):1104–1113.

Yan, J., Kowalczyk, R., Lin, J., Chhetri, M. B., Goh, S.,

and Zhang, J. Y. (2007). Autonomous service level

agreement negotiation for service composition provi-

sion. Future Generation Comp. Syst., 23(6):748–759.

Zeng, L., Benatallah, B., Ngu, A. H. H., Dumas, M.,

Kalagnanam, J., and Chang, H. (2004). Qos-aware

middleware for web services composition. IEEE

Trans. Software Eng., 30(5):311–327.

CLOSER 2011 - International Conference on Cloud Computing and Services Science

684