CONSECUENCIAS JURÍDICAS DE LA RESPONSABILIDAD INTERNACIONAL

The general Mixed Integer Programming (MIP) problem can be formulated as [66]:

max{cx + hy : Ax + Gy ≤ b, x ∈ Zn+, y ∈ R

p

+}, (3.1)

where Zn

+ is the set of nonnegative integral n-dimensional vectors, R

p

+ is the set of nonnegative real

problem is specified by the data (c, h, A, G, b), with c an n-vector, h a p-vector, A an (m × n) matrix, G an (m × p) matrix, and b an m-vector. All data are assumed in Q. MIP is a mathematical model seeking at maximizing a given linear objective function while meeting linear constraints. Linear Programming (LP) is a special case of MIP in which there are no integer variables.

As Web service selection and composition is about maximizing a given utility function (mini- mizing a function is equivalent to maximizing its negative value) while meeting QoS constraints, it can be easily modeled as an MIP problem, assuming that the objective and constraint functions are linear.

For example, Zeng et al. [105] formulate a Web services composition problem and use LP methods

to solve it. In their model, a concrete service composition is represented as an execution plan

instantiating a path in a Directed Acyclic Graph (DAG). Each Web service has a quality vector associated with it. For each possible execution plan, the aggregated quality vector is computed, and an optimal plan can be selected based on Simple Additive Weighting (SAW). However, this method requires that all possible plans are generated. Given N tasks and M potential services for

each task, the resulting computational costs for determining the optimal plan are O(MN_{). It is}

thus not a scalable approach. Therefore, the authors propose an LP-based technique to select the optimal plan, without having to actually generate all the possible ones. In the objective function of the LP problem five QoS attributes (price, duration, reputation, reliability and availability) and

their respective weights are taken into account. Each variable yij has a value of 1 if the respective

service sij is in the selected execution plan, and 0 if not. It thus represents the participation of a

service in a plan. Constraints are formulated on execution duration, price, reliability, availability, and uncertainty of execution duration. The authors use an LP solver based on IBM’s Optimization Solutions and Library to solve the stated LP problem. They finally compare the LP-based global planning approach to local service selection. Global planning results in better overall QoS values, but the computation costs are slightly higher than for local selection.

While QoS-aware service selection problems can naturally be modeled as MIP problems, compu- tational complexity and scalability are important issues that can be addressed by hybrid approaches. Alrifai and Risse [3] also depart from the observation that local service selection, whilst being efficient, does not allow proper handling of global QoS constraints. They propose a solution that combines global and local service selection optimization in order to take advantage of the better QoS results of a global approach and the better performance of a local optimization. To do so, the authors use MIP techniques. As in [105], the authors model the overall problem as an MIP problem. Because of the computational complexity that results in poor scalability, they propose decomposing the problem into two subproblems. In the first phase, the global QoS constraints are decomposed into local constraints on the component services level and they are sent to the involved service brokers. In the second phase, each service broker locally selects the best component service that meets the local constraints. The decomposition of global constraints into local ones is in turn modeled as an optimization problem, and MIP techniques are used to solve it. The decomposition aims to find a set of local constraints for each service class, ensuring that the QoS aggregation still meets all global constraints. This is achieved by introducing quality levels. The computational complexity of the resulting two-step model is determined by the number of abstract services, the number of global QoS constraints, and the number of quality levels and does thus not depend on

3.4. APPROACHES TO SOLVE THE QOS-AWARE SERVICE SELECTION PROBLEM 39 the number of available concrete services, which makes the approach scalable. Evaluations show a significant improvement of the two-step hybrid approach over the global planning in terms of computation time. The achieved results are close to optimal.

Branch-and-Bound (BB) algorithms are often used to solve IP problems and have been widely applied to service selection problems. BB is an enumerative relaxation algorithm [66]. Figure 3.5 shows an enumeration tree a BB algorithm operates on. In this simple example it is assumed that there are three services with two deployments each. Each path from the root element to a leaf element is a possible composition of services S1, S2 and S3.

root S1D1 S1D2 S2D1 S2D2 S2D1 S2D2 S3D1 S3D2 S3D1 S3D2 S3D1 S3D2 S3D1 S3D2 S3 S2 S1

Figure 3.5: Total Enumeration Tree for Branch-and-Bound Algorithms

Yu et al. [104] propose BB-based algorithms for service selection both in the sequential flow and in the general flow model (including parallel and conditional branches). The sequential flow is modeled as an MMKP as defined in Chapter 1 (Section 1.1). The general flow is modeled as an IP problem. As BB algorithms are expensive in terms of computation time, heuristic approaches are also proposed by the authors.

A parallel BB algorithm for the QoS optimization of workflows is proposed in [56]. The authors also model the QoS-aware service selection problem as an MMKP. They introduce the concept of a happiness measure to define the user satisfaction with a given workflow. This measure is based on the aggregation of QoS attributes, and it is the value to be maximized. Solutions to the stated problem are represented as decision vectors d = (d1, ..., dp), where each dv, v = 1, ..., p corresponds

to a service selected for node v. The workflow structure as well as all available services are provided as input. The only global variable, lbound, defines the lower bound for the maximal happiness measure at each state of the algorithm. The happiness measure of each feasible solution constitutes a lower bound for the optimal happiness. Local solutions are computed on each node without taking the overall constraints into account, leading to a relaxation of the problem. In the parallel version proposed by the authors, each node in the decision tree is an instance of the main program and can be run on a separate Grid node each. A notable speedup is observed for the parallel implementation

compared to the serial one if the overall computation time is sufficiently large (i.e., the problem space is above a threshold value) and at least three parallel processes are spawned.