DeepAI
Log In Sign Up

A Methodology for Search Space Reduction in QoS Aware Semantic Web Service Composition

09/19/2018
by   Soumi Chattopadhyay, et al.
4

The semantic information regulates the expressiveness of a web service. State-of-the-art approaches in web services research have used the semantics of a web service for different purposes, mainly for service discovery, composition, execution etc. In this paper, our main focus is on semantic driven Quality of Service (QoS) aware service composition. Most of the contemporary approaches on service composition have used the semantic information to combine the services appropriately to generate the composition solution. However, in this paper, our intention is to use the semantic information to expedite the service composition algorithm. Here, we present a service composition framework that uses semantic information of a web service to generate different clusters, where the services are semantically related within a cluster. Our final aim is to construct a composition solution using these clusters that can efficiently scale to large service spaces, while ensuring solution quality. Experimental results show the efficiency of our proposed method.

READ FULL TEXT VIEW PDF

page 17

page 18

page 19

06/19/2019

Memetic EDA-Based Approaches to Comprehensive Quality-Aware Automated Semantic Web Service Composition

Comprehensive quality-aware automated semantic web service composition i...
02/10/2015

An Integrated Semantic Web Service Discovery and Composition Framework

In this paper we present a theoretical analysis of graph-based service c...
11/28/2011

Graph based E-Government web service composition

Nowadays, e-government has emerged as a government policy to improve the...
03/31/2020

DATESSO: Self-Adapting Service Composition with Debt-Aware Two Levels Constraint Reasoning

The rapidly changing workload of service-based systems can easily cause ...
11/06/2020

Leveraging an Efficient and Semantic Location Embedding to Seek New Ports of Bike Share Services

For short distance traveling in crowded urban areas, bike share services...
09/21/2015

Hybrid Optimization Algorithm for Large-Scale QoS-Aware Service Composition

In this paper we present a hybrid approach for automatic composition of ...
02/18/2019

Evolutionary Multitasking for Semantic Web Service Composition

Web services are basic functions of a software system to support the con...

1. Introduction

With the proliferation of network technologies, services computing has attracted a significant research attention. Web services have become a useful tool to facilitate many necessary activities throughout the world. A web service performs a specific task to satisfy a user requirement. The semantics of a web service (McIlraith et al., 2001) plays an important role in the services life-cycle, for example in service discovery (Paliwal et al., 2012), composition (Rodriguez-Mier et al., 2016; Moser et al., 2012), execution (Botelho et al., 2008), verification (Narayanan and McIlraith, 2002) etc. A web service without any semantic description is often difficult to discover to serve a user request and therefore, may not be considered for execution, even if the service is very relevant to serve a specific user request. In a realistic setting, a number of services are often deployed to fulfill the same purpose. Though these services are intended to serve similar functionality, they may have syntactically different interfaces. Therefore, it is essential to have semantic information along with a service, since sometimes, identifying two semantically related services becomes extremely important to handle a user request efficiently. In general, the functional description of a web service is specified in terms of logical signature annotations and a set of pre and post conditions (Ju et al., 2012b). The semantic information of the services is usually stored in an ontology (Wagner et al., 2011), maintained in a service repository along with the set of services.

The main objective of this paper is to explore the use of semantics for state space reduction in web service composition. A number of research articles (Rodriguez-Mier et al., 2016; Eshuis et al., 2016; Paganelli et al., 2012; Yan et al., 2009; Lécué, 2009) have explored the problem of service composition with semantics. In (Rodriguez-Mier et al., 2016), the semantic information of a service is used only for input-output parameter matching for service discovery and composition. However, the authors in (Rodriguez-Mier et al., 2016) did not consider any precondition / postcondition for a service in their work. In (Eshuis et al., 2016)

, semantic information is used to generate data dependencies to compute a service network, from which an executable composition solution is constructed satisfying the dependencies between the services. An integer linear programming (ILP) based approach proposed in

(Paganelli et al., 2012) uses semantic annotations to make service composition feasible. In (Yan et al., 2009; Rodriguez-Mier et al., 2015), the semantic information is used to combine the services maintaining proper relationship between the services to obtain an optimal QoS aware solution.

With increase in the scale of web services (Wu et al., 2016b), computing the optimal solution is becoming very expensive in terms of computation time and space. A number of scalable web service composition (Chattopadhyay et al., 2017; Lecue and Mehandjiev, 2009) that uses semantic relationship between the services have been proposed in literature. In (Chattopadhyay et al., 2017; Rodriguez-Mier et al., 2011; Aggarwal et al., 2004; Chattopadhyay et al., 2016)

, the semantic information is used to combine the services maintaining the functional dependencies between the services to obtain a heuristic solution. Though these methods are faster than the optimal, they have their own limitations. Many of these fail to deliver the solution with desired quality, since they do not navigate the entire search space.

In this paper, we use the semantic information to expedite the service composition mechanism, while ensuring to obtain the promised quality of the solution. The crux of this work is to identify semantically related services obtained from an ontology (Wagner et al., 2011) stored in a service repository and using this information, form service groups essentially required for generating efficient composition solutions.


Novelty of our work: Our method is built on the foundation of abstraction refinement, a standard technique for handling large state spaces, originally proposed in (Clarke et al., 2000) in the context of formal verification. Abstraction refinement based on syntactic similarity in terms of input-output parameters has been dealt with in our earlier work (Chattopadhyay and Banerjee, 2017). However, the notion of semantics of a web service has not been dealt with in that work. In this paper, we bring the notion of semantics and propose a methodology that provides a scalable way of pruning the composition search space. Our method can be applied on top of any service composition algorithm to improve its performance. In (Wagner et al., 2011), the authors proposed functional clustering based on semantics of the services. However, the focus of (Wagner et al., 2011) is on reducing the search space with the objective of improving the reliability and flexibility, while our focus is to reduce the search space and thus expedite solution composition time. Moreover, the clustering methods that we consider is different from the one in (Wagner et al., 2011).

Our Contribution: In this work, we have the following contributions:

  • We first propose three different types of abstractions based on the semantics of the services in the service repository, that help to reduce the search space and thus to expedite solution computation time.

  • In order to ensure that our algorithm can always produce a valid solution (i.e., a solution satisfying all the constraints), we further propose two refinements corresponding to each abstraction.

  • We perform extensive experiments and it is evident from our experiments that on an average our framework is more efficient, when compared with the performance of the underlying composition algorithm without abstraction.

This paper is organized as follows. Section 2 presents some preliminary concepts. Section 3 demonstrates our proposed methodologies. Section 4 shows the results obtained using our framework. Section 5 includes a discussion on related literature, while Section 6 concludes our paper.

1 2
Method: BWImageToBarcode BinImageToBarcode
Service Name: , ,
Input: BWImage BinImage
Precondition: BWImage must be in jpeg format BinImage must be in jpeg format
BWImage size must be less than BinImage size must be less than
Output: Barcode Barcode
Postcondition: - -
3 4
Method: ImageToBarcode AnyImageToBarcode
Service Name: , , ,
Input: Image Image
Precondition: Image must be in jpeg format Image size must be less than
Image size must be less than
Output: Barcode Barcode
Postcondition: - -
5 6
Method: ImageToIDConverter EuropeanBarcodeToProductID
Service Name: ,
Input: Image EANBC
Precondition: - -
Output: ProductID ProductNumber
Postcondition: - -
7 8
Method: BarcodeToProductID BarcodeToEncoded9ProductID
Service Name: , ,
Input: Barcode Barcode
Precondition: - -
Output: PID
Postcondition: - -
9 10
Method: BarcodeToEncoded14ProductID GetReviewInEnglish
Service Name: , ,
Input: Barcode ProductID
Precondition: - -
Output: Review
Postcondition: - Review written in English
11 12
Method: GetReview GetReviewAndRatingInEnglish
Service Name: , , ,
Input: ProductID
Precondition: - in alpha-numeric value
Output: Review Review, Rating
Postcondition: Review written in local language Review written in English
13 14
Method: GetReviewAndRating GetCheapShopAtPos
Service Name: , , ,
Input: ProductID, GPS
Precondition: in alpha-numeric value -
Output: Review, Rating Price, GPS
Postcondition: Review written in local language GPS must be in the radius of 100 meter
Cheapest price in 100 meter radius
15
Method: GetShopAtPos
Service Name: ,
Input: PID, GPS
Precondition: -
Output: Price, GPS
Postcondition: GPS of the shop is the nearest one
Ontology
Concept: PID, BinImage;
Table 1. DataSet : Service Repository

2. Overview and Problem Formulation

We illustrate our proposal on the following running example as shown in Table 1 containing 32 services to . We consider the following query: A user provides a binary image of the Barcode of of a product in jpeg format with size less than along with his current location to obtain the review of the product in English and the location coordinates GPS of the nearest shop and the product price. The query is formally written as: , {Image in jpeg format, Image size less than }, {Review written in English}, {}, {}). We begin with defining a few terminologies.

Definition 2.1 ().

[Web Service]:  A web service is a 6-tuple , where, and are the set of input and output parameters of respectively. is the method implemented by . are the values of the set of QoS parameters. represents a set of preconditions, defined over and specified in quantifier free first order logic (Lindström, 1966). represents a set of postconditions, defined over the set of output parameters of and specified in quantifier free first order logic.

A web service is executed, once all its inputs are available and the set of preconditions are satisfied. If a web service is executed, it produces the corresponding set of outputs, while ensuring the set of postconditions. The pre and post conditions are optional for a service. Therefore, the pre or post condition / both of them can be null for a service.

Example 2.2 ().

Example services can be found in Table 1. The table contains 32 services to . For each service, a brief description of the method it implemented is provided in the table.

The QoS parameters of a web service are classified into two categories: (a)

Positive QoS, for which a high value is desirable (e.g., reliability) (b) Negative QoS, for which a low value is desirable (e.g., response time).

Two input / output parameters may have syntactically different names. However, both of them may be semantically related. An ontology, which is stored in the service repository along with the web services, maintains all such information. To take into account the semantics of the parameters, a list of concepts and a mapping from each input / output parameter to a concept are maintained in the ontology.

Definition 2.3 ().

[Concept]:  Each input / output parameter corresponding to an ontology maps to a unique entity of the ontology, called a concept.

Definition 2.4 ().

[Parameter mapping]:  Parameter mapping is a mapping of elements in to , where and are respectively the set of input-output parameters and the set of concepts corresponding to an ontology.

Example 2.5 ().

Consider services and in Table 1. takes a BWImage as input, while takes a BinImage as input. According to the ontology, both refer to the same concept binaryImage. Therefore, .

Two concepts and in an ontology are related in either of the following ways: (a) : and are identical concepts. (b) : is a sub concept of , while is a super concept of . (c) : and are not related.

Example 2.6 ().

Consider 4 different concepts: binaryImage, grayImage, RGBImage, Image. The relationship mentioned in an ontology, is as follows: ; ; ;

Definition 2.7 ().

[Query]:  A query is a 6-tuple , where, and are the set of given input and desired output parameters respectively. refers to the input specification, defined over and specified in quantifier free first order logic. represents the output requirement, defined over and specified in quantifier free first order logic. represents a set of QoS constraints, typically, the bounds on the worst case value of the QoS parameters. refers to the objectives of the query (e.g., maximizing throughput, minimizing response time).

Example 2.8 ().

Consider a query. A user provides a binary image of the Barcode of a product in jpeg format with size less than to obtain the review of the product in English. The query is formally written as: , {Image in jpeg format, Image size less than }, {Review written in English}, {Maximum response time is 500ms}, {Maximize the reliability}). The last two elements of the tuple represent QoS constraints and objective of the query respectively. We use this query throughout this paper.

Once a query comes to the system, a set of services are activated based on the query inputs and input specification. We now define the notion of service activation.

Definition 2.9 ().

[Service Activation]:  A service is activated, while serving a query , if the following are satisfied: (a) All the inputs of are available (either query inputs or the set of outputs of already activated services) in the system, i.e., ; such that . (b) All preconditions of defined over its set of inputs are also satisfied either by the query input specification or by the postconditions of the services that are activated by the query, i.e., , where, is the set of services activated by directly / transitively and is the union of the outputs of the services in .

Example 2.10 ().

Consider two services, as defined below

Service Name:
Input: Image ProductName
Precondition: Image in jpeg / png format ProductName in English
Method: GetImageToProduct GetReview
Output: ProductName Review
Postcondition: ProductName in English Review in local language

and a query , {BWImage in jpeg format}, {Review in local language}, {}, {}). According to the ontology, is a sub concept of . Therefore, can be fed as an input to . Moreover, according to the input specification, the BWImage is in jpeg format. Therefore, with the given input specification, the precondition of is also satisfied. Hence, is activated first. Once is activated, from the output of , is also activated, since satisfies . Finally, provides while ensuring the output requirement.

It may be noted, in this paper, we use the symbol to denote is weaker than for any two quantifier free first order logic formulas and . In other words, whenever holds holds as well, however, the converse is not true. Once a query comes to the system, the services are activated directly / transitively. Gradually, a dependency graph (Chattopadhyay et al., 2017) is constructed to serve the query. We now show an example of a dependency graph on our running example.

Example 2.11 ().

Considering our running example (shown in Table 1), the dependency graph, constructed in response to the query (shown in Example 2.8) is shown in Figure 1. Each rectangle presents a group of services having same inputs, outputs, preconditions and postconditions. Each number, situated at the left side of the rectangle, presents the number of services in that group.

Figure 1. Dependency Graph to respond

It may be noted, initially, based on the query inputs and the input specifications, to are activated. From the outputs of to and their postconditions, to are activated. Finally, to , and are activated, that in turn produces the outputs that serve the query and ensure the output requirements. As shown in Figure 1, the dependency graph without abstraction consists of 20 services (rest are not activated). The total number of solutions (in terms of functional dependencies) is 173. The calculation is shown in the figure. Above each rectangle, the calculation shows the number of ways the outputs corresponding to the rectangle can be produced. Finally, the calculation above the query output shows the number of solutions.

We now formally discuss the service composition problem.

Problem formulation: We are given the following:

  1. A set of web services .

  2. A set of concepts .

  3. For each input-output parameter , the mapping to its concept .

  4. A query .

The aim of service composition is to find a set of services to serve the query with appropriate objectives as specified therein. In this paper, our aim is to expedite the process of composition by reducing the search space as explained in the next section.

3. Detailed Methodology

Our framework comprises two key steps: abstraction done at preprocessing time and refinement performed during execution time, i.e., when a query arrives into the system. In the preprocessing phase, a set of services are abstracted based on their functional semantics to obtain a new abstract service. The major advantage of this step is that it reduces the search space and therefore, expedites computation time. Once a query comes to the system, service composition is performed on the abstract service space first. However, the abstraction has a major limitation due to the lack of information of all the services. In some cases, the solution to a query obtained from the abstract service space may not satisfy all the QoS constraints. Therefore, we further propose to refine an abstraction. Refinement is done in the execution phase. The main benefit of this step is that it makes the method complete (Chattopadhyay and Banerjee, 2017). However, an additional computational overhead may be added during composition, if refinement is applied. In the following subsections, we discuss 3 abstraction methods, each followed by the corresponding refinement methods.

3.1. First level Abstraction: Based on Equivalence Relation

We first define the notion of equivalence between services.

Definition 3.1 ().

[Service Equivalence:] Two services are functionally equivalent, expressed as , if the following conditions are satisfied:

The notion of equivalence adopted here is different from the one in (Chattopadhyay and Banerjee, 2017). Here the equivalence is considered in the semantic space and not just based on syntactic names of input-outputs.

Example 3.2 ().

Consider two services and as shown in Table 1. From the definitions of and , , since according to ontology, . Moreover, BWImage in jpeg format BinImage in jpeg format and BWImage size must be less than BinImage size must be less than .

Two services and satisfying the first three conditions of Definition 3.1 are called input equivalent, whereas, two services satisfying the last three conditions of the definition are called output equivalent.

It may be noted, the binary relation defined over a set of services is an equivalence relation. The first level of abstraction is done based on the equivalence relationship between services. Since is an equivalence relation, the service repository is partitioned based on this relation. Each equivalence class is then abstracted by a new representative service. The number of services required to serve a query reduces by this abstraction. Since the service repository is partitioned into a set of equivalence classes and the equivalence classes are mutually exclusive and collectively exhaustive, the number of equivalence classes in the service repository is less than or equal to the number of services in the repository.

Consider be a set of equivalent services. Using the above method, is abstracted by a new service, say . To assign the inputs, outputs of the abstract service, we choose any member service () from its corresponding equivalence class (since each member service is functionally equivalent) and assign the following: . We now illustrate this abstraction on our working example.

Example 3.3 ().

Considering our running example (shown in Table 1), the dependency graph constructed in response to (shown in Example 2.8) with the first level abstract services is shown in Figure 2.

Figure 2. Dependency Graph using first level abstract services to respond

After this abstraction, the dependency graph now consists of 9 services and the total number of solutions (in terms of functional dependencies) is now reduced from 173 to 13. The calculation is shown in the figure.

Once an abstract service is constructed for each equivalence class, it is also important to assign the QoS values to . To do so, we choose a representative service from each corresponding equivalence class and assign the QoS values of the representative service to it. Consider is an abstract service corresponding to the equivalence class . Below, we discuss the method of choosing the representative service.

Step 1: For each service in an equivalence class, we first normalize the values of the QoS parameters between 0 and 1. To normalize, at first, the maximum () and minimum () values of each QoS parameter across the equivalence class are computed. The normalized value of the parameter is computed as:

Step 2: Once the QoS parameters are normalized, we compute the weighted sum of the normalized QoS parameters:

We assume that the weights of the QoS parameters can be provided externally by the user. If no weights are specified, all QoS parameters are provided equal weights, i.e., .

Step 3: The service with maximum weighted sum is chosen as the representative service for each equivalence class.

3.2. Composition with First Level Abstract Services

Any service composition algorithm can be applied over the abstract service space to get a solution to a query. The major advantage of this abstraction method is that for a single QoS parameter, it preserves the solution quality. In other words, if an optimal algorithm is used to find a solution, it is guaranteed to find an optimal solution from the abstract service space as well. Similarly, if a heuristic algorithm is used to find a solution from the abstract space, it is guaranteed that the solution quality does not degrade in comparison to the solution that can be generated from the original / un-abstracted service space by the same algorithm. However, for multiple QoS parameters, we cannot ensure this guarantee. In some scenarios, it may not be possible to generate any solution from the abstract service space that satisfies all the QoS constraints, though one exists in the original service space. In such scenarios, refinement is required. In the next subsection, we discuss the refinement techniques in detail.

3.3. First Level Refinement

In this paper, we consider two refinement techniques: partial refinement and complete refinement.

Partial Refinement

If the composition algorithm returns a solution in terms of the abstract services which does not satisfy all the QoS constraints, we first apply the partial refinement on the solution. It may be noted, one solution in terms of abstract services consists of multiple solutions in terms of original services. The main idea of the partial refinement technique is to change the representative service corresponding to each abstract service belonging to the solution and thus to change the QoS values of the solution. As discussed earlier, the representative service is chosen on the basis of the weighted sum method. Here, we change the weights of the QoS parameters on the basis of the constraint values to choose a different service. We first consider a solution consisting of the set of abstract services . We now discuss how we modify the weights of the QoS parameters.

Step 1: For each abstract service , we find the maximum and the minimum values for each QoS parameter from its corresponding equivalence class.

Step 2: For the solution , we first compute the maximum aggregated value for each QoS parameter , considering as the value of of , for all . Similarly, we compute the minimum aggregated value , for each QoS parameter , considering as the value of of , for all .

Step 3: Among and , we consider one as the best value and the other as the worst value of for the solution. If is a positive (negative) QoS parameter, is considered to be the best (worst) value and is considered to be the worst (best) value of .

Step 4: If the best value of any QoS parameter of the solution does not satisfy the constraint, we do not apply the partial refinement, since, no modification of the representative service corresponding to any abstract service can make the constraint satisfiable.

Step 5: If the worst value of any QoS parameter of the solution is better than the constraint value, we ignore the QoS parameter from the weight computation. This is mainly because, no matter what representative service is chosen for an abstract service belonging to the solution, the constraint value is always satisfied.

Step 6: If the constraint value of (say ) lies between the best and the worst aggregated value, we compute the normalized value of the constraint as:


It may be noted, when we assign the QoS values to an abstract service during the preprocessing phase, we do not have any information regarding the QoS requirements of a query, which can only be known when a query comes to the system during the execution phase. Moreover, the QoS constraints vary across queries. Therefore, in the partial refinement phase, our intuition is to set the weights of the QoS parameters according to the QoS requirements by the query. Since the QoS parameters are disparate in nature, in order to compare them, we first normalize a QoS constraint value with respect to the maximum and minimum aggregated values of the parameter that can be provided by the solution. It may be noted, a solution can provide maximum normalized QoS value as 1 for any QoS parameter. However, a QoS parameter requires the normalized value as to satisfy its corresponding constraint. Therefore, we set the weight of the QoS parameters proportionate to their normalized constraint values.

Step 7: The weight for each QoS parameter is finally computed as,

Once we compute the weights of the QoS parameters, we reiterate the algorithm for choosing the representative service as discussed above and assign the QoS values of the representative service to its corresponding abstract service. Finally, we compute the aggregated QoS values of the solution with the modified abstract services. If the solution now satisfies all the QoS constraints, we return the solution. Otherwise, we apply complete refinement as discussed below.

Example 3.4 ().

Consider a solution to a query as shown in Figure 3, which is a sequential combination of two abstract services and , each corresponding to 3 un-abstract services. Each service has 2 QoS parameters: response time and reliability (as shown by the tuple in the figure). The calculated weighted sum for each service is also shown in figure. For each abstract service, the corresponding representative service is shown by gray color. The QoS values of the solution is . Now consider the following two cases:

Figure 3. A solution using abstract services

Case 1: The query has the following constraints: . Clearly, the solution violates the reliability constraint. Therefore, we apply partial refinement. The maximum and minimum values of the response time corresponding to are 70 and 30ms respectively and the same for are 90 and 30ms respectively. Therefore, the maximum aggregated response time of the solution is 160ms (90 + 70) and the minimum aggregated value for the solution is 60ms (30 + 30). Since the response time constraint is 200ms, we can ignore response time for the weight calculation. This is because whatever representative service is chosen for an abstract service, the response time constraint remains satisfied. Similarly, the maximum and minimum values of the reliability corresponding to are 0.95 and 0.8 respectively and the same for are 0.99 and 0.7 respectively. Therefore, the maximum aggregated reliability of the solution is 0.94 (0.95 * 0.99) and the minimum aggregated value for the solution is 0.56 (0.8 * 0.7). The constraint value lies between 0.94 and 0.56. Therefore, we first calculate the normalized constraint value for reliability . Following the above algorithm, the weights for response time and reliability are 0 and 1 (). Using the calculated weights, we reiterate the algorithm for choosing the representative service. is now the representative service for and is the representative service for , since they have now maximum weighted sum compared to the other members belonging to their corresponding equivalence classes. Hence, the solution now has the QoS values , which satisfies all the constraints.

Case 2: The query has the following constraints: . In this case, the response time constraint can never be satisfied using these two abstract services, since the best response time value for the solution is 60ms. Therefore, complete refinement is required.

Complete Refinement

If the composition algorithm does not return any solution or the partial refinement technique fails to generate a solution, we apply the complete refinement technique. The main idea of the complete refinement is to revert the abstract services to the original services and apply the composition algorithm on the original service space once more to obtain the solution.

3.4. Second level Abstraction: Based on Dominance Relation

This abstraction is done based on the notion of dominance. In this abstraction, we cluster the set of abstract services formed after the step above into further groups, where one service dominates the rest of the services.

Definition 3.5 ().

[Dominance]:  A service dominates another service , expressed as , if the following conditions hold:

  • , such that .

  • , such that .

  • . .

  • and are not output equivalent.

The notion of dominance essentially indicates that the functionality of is covered by the functionality of . In other words, can be activated, if gets activated and provides more functionality than (either provides more outputs or provides more specific outputs, i.e. at least one output of is a sub concept of or the postcondition of implies the postcondition of ). The last condition is used for the next abstraction level.

Example 3.6 ().

Consider two services and , as shown in Figure 2. From their definitions, , since according to ontology, , and {Review} {Review, Rating}. It may be noted, must be activated, if gets activated and provides more outputs than .

Consider is the set of first level abstract services. If a service is not dominated by any other service in (i.e., is non-dominated), forms a group consisting of all the first level abstract services that are dominated by . The group is finally abstracted by a new service, say . The input, output parameters, preconditions and postconditions of are same as . The QoS values of are assigned to . It may be noted, though, every dominated service belongs to at least one group, however, no such service forms its separate group containing all the first level abstract services that are dominated by . The set of services corresponding to and are not always mutually exclusive, since one service can be dominated by multiple services. However, the number of services after the second level of abstraction still reduces. This is because the maximum number of non-dominated services is at most equal to the number of services after the first level.

Example 3.7 ().

Considering our running example (shown in Table 1), the dependency graph constructed in response to (shown in Example 2.8) with the second level abstract services is shown in Figure 4.

Figure 4. Dependency Graph using second level abstract services to respond

The dependency graph now consists of 7 services and the total number of solutions (in terms of functional dependencies) is now reduced from 13 to 7. The calculation is shown in the figure.

As earlier, any service composition algorithm can be applied over the abstract service space to get a solution to a query. However, unlike the first level abstraction, the second level abstraction is not quality preserving. Therefore, refinement may be required even for a single QoS parameter.

3.5. Second Level Refinement

In this level as well, we have two different refinement techniques: partial refinement and complete refinement. The partial refinement here is similar to the previous level. The only difference is that for a second level abstract service , all its corresponding first level abstract services do not participate in selecting the representative service for . This is because of the following reason: consider is the non dominated first level service belonging to the group corresponding to . First of all, it is not necessary, when gets activated all other services in the group are also activated with the available inputs in the system. Furthermore, provides more functionality than any other first level abstract services in that group, which may require serving the query. In this case, no other service can participate in serving the query. Therefore, we have to first select the set of services corresponding to a second level abstract service that can serve the query.

Consider a second level abstract service belonging to the solution corresponding to the set of first level abstract services: , where is the set of first level abstract services. A first level abstract service participates in the representative service selection method, if the following conditions are satisfied: (1) can be activated from the available input set, when is activated. (2) produces all the parameters (in the form of identical / sub concept) that are required to be produced by only, i.e., no other service in the solution produces them. More formally, , where is the set of parameters that are required to be produced by only. (3)The post conditions of must satisfy the set of conditions that are required to be ensured by . More formally, , where, is the set of conditions that are required to be ensured by .

Once the representative services are chosen, the input-output parameters, pre and postconditions and the QoS values are changed according to the chosen representative services. If a valid solution is obtained, we return the solution. Otherwise, we apply the complete refinement technique.

3.6. Abstraction Using Input Implication Output Equivalence

This is the third and the final level of abstraction. The abstraction is done based on the notion of input equivalence and output implication. Here, we focus on the set of services that produce equivalent set of outputs and ensure the same postconditions, however, one service dominates the other service in terms of inputs and preconditions.

Definition 3.8 ().

[Input Implication Output Equivalence Relation (IIOE)]:  IIOE is a relation between two services and (expressed as ), which ensures is output equivalent to and implies in terms of input parameters satisfying the following conditions:

  • , such that .

  • . .

The above definition means, though both the services and provide same output and ensure same functionality, however, is more generic than in a sense that can be activated with less number of inputs or with weaker preconditions (Ju et al., 2012a).

Example 3.9 ().

Consider two services and , as shown in Figure 4. From their definitions, , since both the services are output equivalent and according to the ontology, and .

We first construct an IIOE graph based on the IIOE relation between the services.

Definition 3.10 ().

[IIOE Graph]:  An IIOE graph is a directed acyclic graph, where is the set of nodes and is the set of edges. Each node contains a first-level abstract service . An edge from to exists, if .

We first create all possible nodes and edges in the IIOE graph. Finally, we remove all the transitive edges to make the composition algorithm efficient, as discussed later. If and , we remove the edge from to .

Since, each node contains a second-level abstract service , the number of nodes in is equal to the number of second-level abstract services. Now consider a node in containing an abstract service . It may be noted, if is activated in the system, all the services corresponding to the tree rooted at are also activated at the same time, and provide same functionality as . Therefore, the entire tree is abstracted by a new service, say . In other words, each final level abstract service corresponds to a tree rooted at the node in the implication graph. Therefore, the number of final level abstract services is equal to the number of second level abstract services. The input, output parameters, pre and postconditions of are exactly same as and the QoS assignment technique for this abstraction level is same as the first level abstraction, i.e., for each final level abstract service , we choose a representative service from its corresponding set of second level services and assign its QoS values to .

Example 3.11 ().

Consider three services , and , as shown in Figure 4. From their definitions, , since according to ontology, and , . constructed from the services is shown in Figure 5. Each third level abstract service is shown with a different color in the figure. Considering our running example (shown in Table 1), the dependency graph constructed in response to (shown in Example 2.8) with the final level abstract services is shown in Figure 5.

Figure 5. Dependency Graph using final level abstract services to respond to

After the final level of abstraction, the dependency graph now consists of 5 services and the total number of solutions (in terms of functional dependencies) is now reduced from 7 to 3 ( .).

Though the number of services in this step is exactly same as in the previous step, the number of nodes in the dependency graph reduces from the previous level of abstraction. During composition, if one final-level abstract service is chosen in the dependency graph, no other final level service is chosen for which its corresponding second level service belongs to the tree rooted at the node containing , where corresponds to the tree rooted at . Therefore, the composition algorithm becomes efficient, if it starts traversing the graph top down (i.e., starting from the root node of any connected component of the IIOE graph) during dependency graph construction.

Example 3.12 ().

As shown in Figure 5, if is chosen to serve a query, and are not chosen. Similarly, if is chosen, and are not chosen.

The final level refinement techniques are exactly same as the first level refinement techniques.

3.7. Solution Reconstruction and Analysis

Once a solution is generated in terms of the abstract services, we revert the solution from the abstract space to the original service space. The abstract service in each level is replaced by its previous level service until we reach the original service space. Our framework provides the following guarantees.

Lemma 3.13 ().

Soundness: A QoS constraint satisfying solution containing abstract services produced by any composition algorithm is a valid solution satisfying all QoS constraints on the original service space.

Proof.

Once a QoS constraint satisfying solution is generated in terms of the abstract services, the solution is reverted from the abstract space to the original service space. It may be noted, each () level abstract service of the solution, containing the level abstract services, is replaced by its corresponding previous level service having the same QoS values. Therefore, the overall QoS values of the solution remains unchanged on the original service space. Hence, we always get a valid solution satisfying all QoS constraints on the original service space. ∎

Lemma 3.14 ().

A solution (in terms of functional dependencies) to a query can always be constructed by composing the abstract services, if and only if there exists a solution to the query in the original service space.

Proof.

We first consider the following cases:

  • If any service is eventually activated from the query inputs and input specification, the abstract service containing must be activated, since both of them are functionally equivalent and will produce the set of outputs and identical postconditions, that further producing the query outputs eventually with desired output requirements, if there exists a solution to the query.

  • If any service is eventually activated from the query inputs and input specification, the abstract service containing must be activated, since the representative service of either itself or dominates . Therefore, will produce the set of outputs containing the output set of having stronger postconditions, that further producing the query outputs eventually with desired output requirements, if there exists a solution to the query.

  • For each service , there exist a third level abstract service having identical set of inputs, outputs, preconditions and postconditions. Therefore, the same argument holds for this case as well.

Therefore, if there exists a solution to a query in the original service space, we can always construct a solution in terms of the functional dependencies by composing any level of abstract services. ∎

Our entire framework provides the following guarantee.

Lemma 3.15 ().

Our framework is always able to find a valid solution, if one exists.

If no solution is found from an abstraction level, we can always go back to the previous level by applying the complete refinement and search for the solution. In the worst case, we may end up searching for a solution in the original service space. Therefore, we never miss a solution, if one exists.

4. Experimental Results

Our proposed algorithms were implemented in Java. We implemented our framework on top of two composition algorithms (Chattopadhyay et al., 2016) and (Xia et al., 2013). We first applied our framework on the WSC-2008 datasets (Bansal et al., 2008). Since the services in the WSC dataset are generated complete randomly (Wagner et al., 2011), we did not find significant reduction in any abstraction step. For the dataset, we found 1 pair of equivalent services, for the dataset 1 pair of equivalent services and 1 pair of dominant services and finally for the dataset, we found 2 pairs of dominant services. For rest of the datasets, we could not find any reduction due to abstraction. Hence, our framework could not provide significant performance gain for WSC-2008 datasets. Therefore, we demonstrate our method on a synthetically generated dataset.

Our synthetic dataset is an extension of our example dataset as shown in Table 1. Our example dataset is constructed from the dataset described in (Wagner et al., 2011)

. We now discuss the construction of our synthetic dataset. We first generated a random number of concepts and assigned a random relationship (identical / sub / super / unrelated) between the concepts. We then randomly generated the number of input-output parameters and randomly associated them with the concepts. However, the services were also generated in a semi random manner. We increased the number of services in a random manner maintaining the relationship (equivalence / dominance / IIOE / unrelated) between the services as discussed above and accordingly assigned the input-output parameters, preconditions and postconditions. Finally, we generated the QoS parameters of the services. In this paper, we considered 4 QoS parameters: response time, throughput, reliability, availability and modeled them assuming they follow normal distribution

(Zheng et al., Zheng et al.). Once the service repository was created, we generated a random query having random inputs, outputs, input-specifications, output-requirements and QoS constraints. We now analyze the results.

DataSet Abs. 0 Abs. 1 Abs. 2 Abs. 3
RDS1 731 70 56 28 10.44 1.25 2
RDS2 3493 109 89 19 32.05 1.22 4.68
RDS3 6159 380 221 154 16.21 1.72 1.44
RDS4 17930 893 532 334 20.08 1.68 1.59
RDS5 15904 874 421 343 18.2 2.08 1.23
Table 2. Computation Time (ms) and speed up for dependency graph construction
DataSet Abs. 0 Abs. 1 Abs. 2 Abs. 3
RDS1 37523858 2111240 1921228 884105 17.77 1.1 2.17
RDS2 348775813 6014884 5817691 1079896 57.99 1.03 5.39
RDS3 192147284 3180854 3021811 2012347 60.41 1.05 1.50
RDS4 389731251 17119550 15407595 3599254 22.77 1.11 4.28
RDS5 209139820 4896525 4651698 3370275 42.71 1.05 1.38
Table 3. Computation Time (ns) and speed up for optimal RT computation
DataSet Abs. 0 Abs. 1 Abs. 2 Abs. 3
RDS1 37098104 2127783 1978838 1027102 17.44 1.075 1.93
RDS2 425637217 3029113 2998821 1040155 140.52 1.01 2.88
RDS3 281199735 3893887 3777070 2154407 72.22 1.03 1.75
RDS4 38649038 7178013 7106232 2382924 5.38 1.01 2.98
RDS5 264711653 3455560 3386448 2291248 76.60 1.02 1.48
Table 4. Computation Time (ns) and speed up for optimal throughput computation
Level Exp. 1 Exp. 2 Exp. 3
# Services Time # Services Time # Services Time Time Time
Abs. 0 3846 29862 9718 25896 98361 - - -
Abs. 1 1297 11596 6389 13791 53846 - - -
Abs. 2 1123 3276 5231 11563 15926 3695 - -
Abs. 3 201 9698 1226 2215 1856 1532 7197 23458
Table 5. Computation Time (ms) for constraint satisfying solution computation

We present our experiment in two parts. In the first part, we show the performance gain achieved by our framework at runtime, when implemented on top of (Xia et al., 2013). Figure 6 shows the reduction in the number of services in the service repository by applying each abstraction level for 5 random datasets ( to ). Figure 7 shows the reduction in the number of services in the dependency graph constructed to respond to a query by applying each abstraction level for 5 random datasets. On an average, there are 6x, 10x and 16x reductions in the number of services in the dependency graph for abstraction levels 1, 2 and 3 respectively with respect to the number of unabstracted services. Table 2 shows the computation time to construct the dependency graph generated in response to the query for each of the 3 abstractions. Columns to of the table show the computation time required by the underlying algorithm for 4 levels of services (the level corresponds to without abstraction). Columns to of the table show the speed up () for () abstraction level respectively with respect to the un-abstracted service space (i.e., Level 0). As evident from the table, we achieved, on an average, 19x, 30x, 70x speed up for abstraction levels 1, 2 and 3 respectively. Figure 8 shows the response time (RT) obtained by Algorithm (Xia et al., 2013) for 4 levels of services. The response time obtained by our framework, on an average, degrades 4x, 5x, 6x for abstraction levels 1, 2 and 3 respectively, while the computation speed up achieved by our framework to compute response time is on an average 40x, 43x, 126x (shown in Table 3). Similarly, the throughput obtained by our framework, on an average, degrades 1.28x, 1.33x, 1.36x respectively for abstraction levels 1, 2 and 3 (shown in Figure 9), while the speed up achieved by our framework to compute throughput is on an average 62x, 64x, 142x (as in Table 4).

Figure 6. No. of services in service repository
Figure 7. No. of services in dependency graph
Figure 8. Response Time
Figure 9. Throughput

In the second part of our experiment, we show the performance of our framework implemented on top of (Chattopadhyay et al., 2016). Here, we considered the query having QoS constraints. We conducted three sets of experiments (Exp. 1, Exp. 2 and Exp. 3 of Table 5) varying the number of services and query and recorded the computation time to serve a query. In the final experiment (Exp. 3 of Table 5), we varied the constraints of the QoS parameters ( Column has tighter constraints than , which has tighter constraints than ) for the same query and recorded the result. As can be seen from the table, in all 3 experiments, as the abstraction level increases, the number of services either remains same or decreases, which we have claimed in this paper. However, it is not guaranteed that the computation time to find a solution always improves as the abstraction level increases, because in some cases, complete refinement is necessary (as can be seen in the first experiment). In the first experiment, we have shown as the abstraction level increases, the time requirement to compute a solution decreases upto the level of abstraction. However, in the abstraction level, the time requirement increases. It is due to the fact that in the level of abstraction no solution could be found. Therefore, complete refinement was performed. In the last experiment, “-” indicates no solution is generated due to time out. It may be noted, no solution was generated in the lower level of abstraction as well. However, at the higher level, we obtained a solution. It may be observed, on an average, the composition algorithm in the abstract service space outperforms the composition algorithm in the un-abstract service space.

5. Related Work

Research on service composition has been carried out in multiple directions. A significant amount of work considering semantic web service composition has been performed considering optimality being the primary concern (e.g., graph based approaches (Chen and Yan, 2012; Rodriguez-Mier et al., 2015), ILP based approaches (Chattopadhyay et al., 2016; Schuller et al., 2012), AI planning based approaches (Oh et al., 2008; Mostafa and Zhang, 2015)). However, in real time, optimality has proved to be an expensive requirement (Lecue and Mehandjiev, 2009; Chattopadhyay et al., 2017) for service composition, since most of the optimal methods do not scale for large service repositories. Therefore, a number of heuristic methods (Wu et al., 2016a; Rodriguez-Mier et al., 2011; Guidara et al., 2015; El Hadad et al., 2010) have been proposed, where computation time is considered as the main objective. In (Alrifai et al., 2010) and (Alrifai et al., 2009), authors have proposed a multi constrained QoS aware service composition approach, instead of finding the optimal solutions. Dynamic binding is the main concern of (Alrifai et al., 2009)

, where authors propose to generate the skyline services for each task and cluster the services using the K-means algorithm. In

(Alrifai et al., 2010), authors proposed an Integer Linear Programming (ILP) based approach, where ILP is used to divide the global constraints into a set of local constraints and then using the local constraints, the service selection is done for each task. In (Schuller et al., 2012)

, authors proposed ILP based methods to solve multi-constrained service composition. A significant amount of work has been done based on evolutionary algorithms, such as Particle Swarm Optimization

(Liao et al., 2013), Ant Colony Optimization (Shanshan et al., 2012), Bee Colony Optimization (Liu et al., 2014)

, Genetic Algorithms

(Zhang et al., 2013; Wang and Hou, 2008), NSGA2 (Hashmi et al., 2013; Wagner et al., 2012). Though these algorithms can rapidly generate solutions and handle large and complex service spaces (Lecue and Mehandjiev, 2009), they compromise on the solution quality (Song et al., 2011; Pistore et al., 2005). In (Yan and Chen, 2015), the authors proposed a planning graph based approach and an anytime algorithm (Yan and Chen, 2015) that attempts to maximize the utility. In (Zeng et al., 2003), authors proposed an ILP based method to maximize the utility. In (Chattopadhyay et al., 2016), the authors proposed ILP based multi-constrained service composition. In (Cao et al., 2007), the authors analyze the relation between multi-objective service composition and the Multi-choice, Multi-dimension 0-1 Knapsack Problem (MMKP). There are few methods (Lecue and Mehandjiev, 2009; Chattopadhyay et al., 2017) in literature, that enlighten the issue of search space reduction of the composition algorithm. However, they often fail to generate a solution with desired quality.

In contrast to existing literature, we propose a framework for semantic web service composition based on abstraction refinement that aims to expedite the solution construction time by reducing the search space without compromising on the solution quality. Service clustering based on syntactic similarity in terms of input-output parameters has been dealt with in our earlier work (Chattopadhyay and Banerjee, 2017). However, the notion of semantics of a web service has not been dealt with in that work. In this paper, we bring the notion of semantics and propose a methodology that provides a scalable way of pruning the composition search space. Our method can be applied on top of any service composition algorithm to improve its performance. To conclude, we do not propose any new service composition algorithm, rather a framework on top of existing algorithms. This adds a unique novelty to this work.

6. Conclusion

This paper presents an approach for reducing the search space for semantic web service composition based on abstraction refinement. For a large dataset, the approach can be quite efficient, since it greatly improves performance. As future work, we are currently working on designing more sophisticated refinement techniques. We also aim to perform more extensive experiments of this framework on real datasets.

References

  • (1)
  • Aggarwal et al. (2004) R. Aggarwal and others. 2004. Constraint driven Web service composition in METEOR-S. In SCC. 23–30.
  • Alrifai et al. (2009) Mohammad Alrifai and others. 2009. Combining global optimization with local selection for efficient QoS-aware service composition. In WWW. 881–890.
  • Alrifai et al. (2010) Mohammad Alrifai and others. 2010. Selecting Skyline Services for QoS-based Web Service Composition. In WWW. 11–20.
  • Bansal et al. (2008) Ajay Bansal and others. 2008. WSC-08: continuing the web services challenge. In E-Commerce Technology and the Fifth IEEE Conference on Enterprise Computing, E-Commerce and E-Services, 2008 10th IEEE Conference on. IEEE, 351–354.
  • Botelho et al. (2008) Luis M Botelho, António L Lopes, Thorsten Möller, and Heiko Schuldt. 2008. Semantic web service execution. In CASCOM: Intelligent Service Coordination in the Semantic Web. Springer, 263–287.
  • Cao et al. (2007) Hefeng Cao and others. 2007. A service selection model with multiple QoS constraints on the MMKP. In NPC Workshops. IEEE, 584–589.
  • Chattopadhyay et al. (2016) Soumi Chattopadhyay and others. 2016. QSCAS: QoS Aware Web Service Composition Algorithms with Stochastic Parameters. In ICWS. 388–395.
  • Chattopadhyay et al. (2017) Soumi Chattopadhyay and others. 2017. A Fast and Scalable Mechanism for Web Service Composition. TWEB 11, 4 (2017), 26:1–26:36.
  • Chattopadhyay and Banerjee (2017) S. Chattopadhyay and A. Banerjee. 2017. QoS constrained Large Scale Web Service Composition using Abstraction Refinement. IEEE TSC PP, 99 (2017), 1–1. DOI:http://dx.doi.org/10.1109/TSC.2017.2707548 
  • Chen and Yan (2012) Min Chen and Yuhong Yan. 2012. Redundant service removal in qos-aware service composition. In ICWS. 431–439.
  • Clarke et al. (2000) Edmund Clarke and others. 2000. Counterexample-guided abstraction refinement. In CAV. 154–169.
  • El Hadad et al. (2010) Joyce El Hadad and others. 2010. TQoS: Transactional and QoS-aware selection algorithm for automatic Web service composition. IEEE TSC 3, 1 (2010), 73–85.
  • Eshuis et al. (2016) Rik Eshuis and others. 2016. Flexible Construction of Executable Service Compositions from Reusable Semantic Knowledge. TWEB 10, 1 (2016), 5–.
  • Guidara et al. (2015) Ikbel Guidara and others. 2015. Heuristic based Time-aware Service Selection Approach. In ICWS. IEEE, 65–72.
  • Hashmi et al. (2013) Khayyam Hashmi and others. 2013. Automated Web service quality component negotiation using NSGA-2. In AICCSA. IEEE, 1–6.
  • Ju et al. (2012a) Lei Ju and others. 2012a. Tenant Onboarding in Evolving Multi-tenant Software-as-a-Service Systems. In ICWS. 415–422.
  • Ju et al. (2012b) Lei Ju, B. Sengupta, and A. Roychoudhury. 2012b. Tenant Onboarding in Evolving Multi-tenant Software-as-a-Service Systems. In ICWS.
  • Lécué (2009) Freddy Lécué. 2009. Optimizing qos-aware semantic web service composition. In ICWS.
  • Lecue and Mehandjiev (2009) Freddy Lecue and Nikolay Mehandjiev. 2009. Towards scalability of quality driven semantic web service composition. In ICWS. 469–476.
  • Liao et al. (2013) Jianxin Liao and others. 2013. A multi-objective service selection algorithm for service composition. In APCC. IEEE, 75–80.
  • Lindström (1966) Per Lindström. 1966. First order predicate logic with generalized quantifiers. Theoria 32, 3 (1966), 186–195.
  • Liu et al. (2014) Ruilin Liu and others. 2014. Parameter tuning for ABC-based service composition with end-to-end QoS constraints. In ICWS. IEEE, 590–597.
  • McIlraith et al. (2001) Sheila A McIlraith, Tran Cao Son, and Honglei Zeng. 2001. Semantic web services. IEEE intelligent systems 16, 2 (2001), 46–53.
  • Moser et al. (2012) Oliver Moser, Florian Rosenberg, and Schahram Dustdar. 2012. Domain-specific service selection for composite services. IEEE Transactions on Software Engineering 38, 4 (2012), 828–843.
  • Mostafa and Zhang (2015) Ahmed Mostafa and Minjie Zhang. 2015. Multi-objective service composition in uncertain environments. IEEE TSC PP, 99 (2015), 1–1.
  • Narayanan and McIlraith (2002) Srini Narayanan and Sheila A McIlraith. 2002. Simulation, verification and automated composition of web services. In Proceedings of the 11th international conference on World Wide Web. ACM, 77–88.
  • Oh et al. (2008) Seog-Chan Oh and others. 2008. Effective web service composition in diverse and large-scale service networks. IEEE TSC 1, 1 (2008), 15–32.
  • Paganelli et al. (2012) Federica Paganelli and others. 2012. A QoS-aware service composition approach based on semantic annotations and integer programming. IJWIS 8, 3 (2012), 296–321.
  • Paliwal et al. (2012) Aabhas V Paliwal, Basit Shafiq, Jaideep Vaidya, Hui Xiong, and Nabil Adam. 2012. Semantics-based automated service discovery. IEEE Transactions on Services Computing 5, 2 (2012), 260–275.
  • Pistore et al. (2005) Marco Pistore and others. 2005. Automated composition of web services by planning at the knowledge level. In IJCAI. 1252–1259.
  • Rodriguez-Mier et al. (2011) Pablo Rodriguez-Mier and others. 2011. Automatic web service composition with a heuristic-based search algorithm. In ICWS. 81–88.
  • Rodriguez-Mier et al. (2015) Pablo Rodriguez-Mier and others. 2015. Hybrid Optimization Algorithm for Large-Scale QoS-Aware Service Composition. TSC (2015).
  • Rodriguez-Mier et al. (2016) Pablo Rodriguez-Mier, Carlos Pedrinaci, Manuel Lama, and Manuel Mucientes. 2016. An integrated semantic web service discovery and composition framework. IEEE transactions on services computing 9, 4 (2016), 537–550.
  • Schuller et al. (2012) Dieter Schuller and others. 2012. Cost-driven optimization of complex service-based workflows for stochastic QoS parameters. In ICWS. 66–73.
  • Shanshan et al. (2012) Zhao Shanshan and others. 2012. An improved ant colony optimization algorithm for QoS-aware dynamic web service composition. In ICICEE. IEEE, 1998–2001.
  • Song et al. (2011) Xudong Song and others. 2011. A workflow framework for intelligent service composition. FGCS 27, 5 (2011), 627–636.
  • Wagner et al. (2011) Florian Wagner and others. 2011. QoS-aware automatic service composition by applying functional clustering. In ICWS. IEEE, 89–96.
  • Wagner et al. (2012) Florian Wagner and others. 2012. Multi-objective service composition with time-and input-dependent QoS. In ICWS. IEEE, 234–241.
  • Wang and Hou (2008) Junli Wang and Yubing Hou. 2008. Optimal web service selection based on multi-objective genetic algorithm. In ISCID, Vol. 1. IEEE, 553–556.
  • Wu et al. (2016a) Quanwang Wu and others. 2016a. QoS-Aware Multigranularity Service Composition: Modeling and Optimization. IEEE TSMC 46 (2016), 1565–1577.
  • Wu et al. (2016b) Y. Wu and others. 2016b. A Multilevel Index Model to Expedite Web Service Discovery and Composition in Large-Scale Service Repositories. IEEE TSC 9, 3 (2016), 330–342.
  • Xia et al. (2013) Yong-Min Xia and others. 2013. Web Service Composition Integrating QoS Optimization and Redundancy Removal. In ICWS. 203–210.
  • Yan et al. (2009) Yixin Yan and others. 2009. A qos-driven approach for semantic service composition. In IEEE ICCEC. IEEE, 523–526.
  • Yan and Chen (2015) Yuhong Yan and Min Chen. 2015. Anytime QoS-aware service composition over the GraphPlan. Springer SOCA 9, 1 (2015), 1–19.
  • Zeng et al. (2003) Liangzhao Zeng and others. 2003. Quality driven web services composition. In WWW. ACM, 411–421.
  • Zhang et al. (2013) Zhichao Zhang and others. 2013. Genetic algorithm for context-aware service composition based on context space model. In ICWS. IEEE, 605–606.
  • Zheng et al. (Zheng et al.) H. Zheng and others.

    QoSDIST: A QoS Probability Distribution Estimation Tool for Web Service Compositions. In

    IEEE APSCC, 2010. 131–138.
    DOI:http://dx.doi.org/10.1109/APSCC.2010.19