Autonomic Flap Damping Mechanisms for Utility based Service Selection Johann Bourcier1, 2 and Julie McCann1 1

2

Imperial College of London, Department of Computing, 180 Queens Gate, LONDON, SW7 2BZ, United Kingdom {jbourcie, jamm}@doc.ic.ac.uk

Grenoble University - Laboratoire LIG-IMAG, 220 rue de la Chimie Domaine Universitaire, BP 53 F-38041 Grenoble, Cedex 9, France [email protected]

Abstract— The service oriented computing paradigm can be described as consisting of the following major components: service providers, service consumers and one or more service trader. One of the most challenging problems in this field has surrounded the choice of service provider in the presence of several, that best matches the consumer requirements. There has been a body of work exploring quality measures as a means of discerning between services. However, in much of the previous work the service selection remains relatively static during the life-time of the session, yet finer-granularity is required by Pervasive applications to drive their selfconfiguration, repair and management. Therefore how subtle changes in service quality affect the service choice, and ultimately the system's optimal performance in terms of its goals, is less well understood. In this paper, we propose a utility-function driven framework that dynamically chooses the most suitable providers for each consumer; driving selfoptimization. We evaluate the performance and accuracy of our solution by implementing a pervasive home video application. Our results show our framework imposes minimal overheads while offering good response time and an accurate choices to the provider. Further, we observe that under less stable conditions, the framework state-flaps quite severely, producing oscillations between consumer-service bindings; increasing overheads. To this end, we have established several mechanisms that minimize the number of oscillations under unstable conditions and have evaluated each in terms of their ability to maintain stability under differing degrees of volatility. Services, Component, Autonomic binding, utility functions, OSGi, iPOJO

I.

INTRODUCTION

The Service oriented Computing [1] paradigm has recently gained major attention from both industry and academia. This new computing paradigm aims to provide a new way of designing applications by assembling services, thus providing great flexibility to self-manage due to the loose coupling of entities composing an application. Though, this programming paradigm has been mainly applied to enable the integration of cross enterprise IT systems, some of

our prior work [2, 3] has demonstrated the benefit of using such technology in the field of Pervasive applications. Service oriented computing is based on three major components: service providers, service consumers and one or more service trader. A service consumer connects to a service provider by asking the trader for a suitable provider. The consumer is then able to locate and invoke a provider of the desired service. In this paper, we consider an approach we called the Dynamic Service Oriented Computing which refers to a subpart of this programming paradigm capable of handling the dynamic appearance and disappearance of service providers available to the consumer. Many service oriented computing technologies [4, 5, 6] are able to support this approach. However, there is less work concerning fine-grain dynamics of the service environment. In this paper, we tackle the problem of choosing the best suited provider for a particular consumer with a particular emphasis on the field of Pervasive Computing (however our work is not exclusive to this field). Indeed, it is often the case that several providers of the same service are present at the same time in the execution environment, and the consumer has to pick one. We believe that a framework based solution; taking into account the particular needs of service consumers will provide a much better and more flexible way of dealing with this problem. This issue becomes crucial in the pervasive computing application domain. Indeed, pervasive applications are accessing services provided by actual physical devices with different characteristics. For example, an application may want to communicate to the user via accessing a display mechanism that can be provided, either by a TV set, a computer screen, a PDA, or even by some loud speakers equipped with text to speech facilities, for example. All these devices have the capacity to provide the machine-to-human communication service but with different characteristics, qualities etc. Here we cannot define a generic best choice, as this choice depends on the application needs as well as what is available to the application at that time (i.e. the current context). Here the user may be viewing data on the TV and walk into the Kitchen whereby the data needs to be relayed

to the Fridge’s computer screen. This probleem becomes even more important while considering the casee of the dynamic availability of services and actual devices, either due to this context change or even device unreliabiility (e.g. phone batteries depleted). Furthermore the PDA caan move with the user and becomes out of reach of the wireleess network, thus making this display unusable for the applicattion. In this paper, we propose an autonomic service selection framework that is able to automatically findd the best service provider for a particular consumer takingg their particular wishes into account. First, the consumer deffines his needs by means of a utility function. This function m maps the value of the various service providers’ characteristtics, to a single metric evaluating the utility of a particular pprovider from the consumer point of view. Then, the fram mework has the possibility to find the best suited provider foor each consumer. The framework constantly monitors the evolution of the service providers’ characteristics, and thus can dynamically modify the bindings between consumer aand services. We have built a prototype of this framework on top of OSGi and a Service oriented component framework caalled iPOJO, and have evaluated its benefit with two concrette applications in the field of pervasive computing. During the evaluation of this work, we hhave noticed that in a highly dynamic environment such as thhe one typified by pervasive applications, the best suitedd provider can potentially change very often. As changing from one service provider to another can be a costly operaation in terms of unnecessary overheads or in terms of deelivering a poor service (i.e. flicking or flapping between TV and Fridge screen when the consumer is on the rroom boundary). Therefore some service consumers may w want to limit or dampen these changes. To this end we propose several mechanisms that manage flap damping connsumer, which we implement and evaluate. The rest of this paper is organised as follows. First, in section 2, we present some background rregarding service oriented computing and focus particulaarly on service oriented component frameworks, and the benefit of using such technologies in the pervasive compuuting domain. In section 3, we introduce a motivating sceenario. We then introduce the main concepts of our fram mework, and its operation, in section 4. The section 5 followed, by a description of the implementation and the reesult of our actual experimentations. The section 6 then descrribes our various flap damping mechanisms, the methods uused to integrate them into the framework and their corresponnding evaluation. The section 7 is dedicated to related work off this project. We conclude, in section 8, by detailing the lessons learned from this work and giving some perspective of ouur future work. II.

BACKGROUND - IPOJO O

Service-Oriented Computing (SOC) [11] is a relatively new trend in software engineering wherebyy services can be supplied by multiple service providers andd feature various implementations. At runtime, a service connsumer is able to invoke a service by relying only on the servvice specification. An important consequence of this interactioon pattern is that SOC technologies support dynamic servicce discovery and

lazy inter-service binding. Such characteristics are essential when building applications wiith strong adaptability requirements, such as pervasive and residential applications. iPOJO [7] is a service oriented component runtime that o applications on top of aims to simplify the development of OSGi [6] SOC Platforms. iPOJO alllows the straightforward development of application logic based b on Plain Old Java Objects (POJO). iPOJO subsequenttly injects non-functional facilities into the application compo onents, as necessary. Such facilities include service provision ning, service dependency and lifecycle management. In addition a to providing a reusable set of non-functional capabilities, iPOJO is ude new middleware seamlessly extensible to inclu functionalities. ges the advantages of The iPOJO framework merg components with service oriented paradigms. Specifically, iPOJO application functionalities arre implemented following the component orientation paradig gm. Each component is fully encapsulated, self-sufficient, and provides server and client interfaces exposing itss functionalities and dependencies, respectively. As many m component-oriented platforms (e.g. Java EE and .NE ET), iPOJO separates a component’s application-specific business b logic from its application independent function ns. As such, iPOJO components consist of a componen nt implementation that is managed by a reusable container (Fiigure 1).

Figure 1. Internal design of an iPOJO component

iPOJO containers provide common middleware functionalities to the componentt implementations they manage (e.g. distributed commu unication and lifecycle management). Each component con ntainer can be configured with a different set of middleware services, implemented as mponent is deployed, its “handlers”. Once an iPOJO com provided functions are published and made available as services, in conformance with the SOC paradigm. In order for a component’s services to become valid, all the component’s dependencies must be resolved. For this purpose, available services correspo onding to a component’s required (or client) interfaces must be b found and available. A. H-OMEGA: A Residential Gatew way based on SOC technology ve investigated an open In our previous work we hav infrastructure for building and d executing residential applications: H-Omega [2]. The maiin part of this architecture is the residential gateway that can be seen as a home application server. Residential appliications are deployed and run on this gateway. This gateway has h the ability to discover

and interact with dynamic devices inside thhe home and also with external services. Figure 2 shows the internal design oof the H-Omega residential server. All available devicess are reified as services in the framework. The life cycle of these services follows the availability of the device they represent. These services are responsible for the communnication between applications and the actual devices. The lifecycle of these particular services is managed by a server entity called the remote service manager. Application devveloper can then rely on these services to build their own appplication without taking care of all the tricky problems of deevice distribution, heterogeneity and dynamism.

Nevertheless, providing such smart s adaptable behavior raises other challenges. Indeed, swittching from one provider to another interrupts the serv vice delivery, and as reconnecting to another video stream is not cost and time free, the resulting consumer satisfacction can be decreased, if this adaptation occurs too often. Thus, the focus of this paper.

Figure 3. Pervasive Video o Application

IV.

A UTILITY FUNCTION BASSED FRAMEWORK FOR AUTONOMIC SERVICE SELECTION

Figure 2. H-Omega application server arcchitecture

III.

MOTIVATING SCENARIIOS

The problem of automatically and dynam mically choosing the best service provider for a particular consumer is far broader than the domain of pervassive computing. Nevertheless, in this paper, we have deciided to focus on demonstrating the main benefits of usinng an autonomic service selection framework in the conteext of pervasive applications. We have developed a video sttreaming Serviceoriented application to highlight the bbenefits of our architecture and evaluate the performance off our solution. Our application aims to deliver a particuular video stream to one user of a pervasive home enviroonment. For this purpose, the application has access to threee internet video broadcasters and a set of home devices thaat can display the video stream. The architecture of the appliccation is depicted in Figure 3. The video stream broadcaster proposes the same video quality (resolution, color depth, enccoding, etc), but with different and varying bandwidth due tto the number of connected clients. Several devices, with the ability to display the video stream, are available in the house such as a TV set, a computer screen, and a PDA. The service quality provided by all provviders is not equal and moreover varies throughout the exxecution of the application. Thus, the behavior of our appliication will be to choose the best stream provider according too the metrics that the consumer has specified. This bandwiddth is constantly monitored in order to optimize the appliication behavior. Whenever a better video stream providder appears, the application adapts itself in order to use the best provider.

Our approach proposes a sollution for automatically choosing the best suited service provider p for a particular consumer according to the current context. A consumer has p need according to choose the best provider for his particular to what is advertised form each prrovider. In this work, we assume that all information provideed by the service provider is accurate and true (we are currenttly working on removing this assumption, but this is beyond th he scope of this paper). We propose to use utility functio ons to express the need of a consumer. We also propose to asssociate a utility value to each service provider according to th he value of the properties they advertise. Thus, we are able to o attribute a score to each service provider. A utility value below or equal to zero ble. The higher the value means that the provider is not suitab is, the best the provider matches th he need of the consumer. Our framework is thus able to au utomatically calculate the score of each provider then rank th hem and finally provide a connection to the best one. Using this technique provides the required degree of d powerful language to flexibility, and a very rich and accurately express the need of a customer. Indeed, the function has the possibility to rejecct particular providers by providing a negative value. It is also a able to express the utility according to the value or presence of certain properties. For example, a consum mer may require a video stream of high resolution, and th hus rating the provider according to the value of the reso olution property. Another interesting example is a consum mer that is interested in providers that ‘do not have trouble streaming video’. In this particular case, the consumer will w rank the provider according to the rate between the resolution and the bandwidth provided. Thus, utilitty functions allow the expression of complex policies for choosing among a set of provider of the same service, and yeet do so in a light enough

way suitable to pervasive applications runnning on resource constrained devices. In our approach, new service providers are dynamically available, and they can freely modifyy their exposed properties, thus changing their utility valuee for consumers. To deal with this aspect, our framework connstantly computes the score of each provider in order to permannently choose the best suited available provider. mic availability of Although our approach supports dynam providers and dynamic modification of published properties, we have to support modification of requirrements from the consumer. For example, in the scenario preesented in section 3, under normal conditions, the TV will bee preferred to the PDA due to the size of the screen. But, when the social context of the user changes (other peoplee may enter the house), a more private screen, such as thee PDA, could be better. To deal with that, our framework prrovides a way of dynamically modifying the utility functtion used by a consumer. In order to support such dynam mic modification, the framework has the ability to recompute the provider utility value at any time. This need not bee initiated by the customer; a policy engine can store the consumer preferences and map this to the utility functions accordingly. V.

MENTATIONS IMPLEMENTATION AND EXPERIM

To implement our framework, we have decided to avoid with our particular centralized management, as it does not fit w problem. Indeed, each client has his ow wn requirements, which made it impossible to centralize the ccalculation of the best provider. Therefore, we have a complettely decentralized way of resolving this problem. A. iPOJO framework Our implementation prototype has beeen made on the iPOJO service oriented component framewoork [7]. In iPOJO, a component expresses his needs of servicess by pointing to a special service description and giving a filtter that is able to sort service providers between acceptable or unacceptable. The framework is then able to manaage the service dependency according to the policy givenn by the filter. It means that the framework will find one suittable provider for the consumer and binds to it. The frameworrk then tracks the availability of all providers and in the eevent of the one currently used becoming unavailable or unsuitable, the framework choose another one and binds to it. Thus, the consumer is always connected to the best prrovider according to his own requirements.

Figure 4. Modification of the iPOJO Coontainer

The Figure 4 shows how we haave integrate our work in the iPOJO framework. As shown in n Figure 4, we also have given a way to access the policy (th he utility function) of our handler, in order to be able to monitor m and dynamically reconfigure this policy. This accesss is made through JMX (Java Management Extension), whicch is the de facto standard for Java management. It enables extternal entities to remotely access to the utility function and mo odify it. One of the main benefits of using JMX is the em mbedded security which prevent unauthorized entities to o access the managed resource. In our case, it protectts the component from unwanted modification of his requ uirements. When a new utility function is sent, our handlerr catches it and clears all the previous utility values of avaailable providers. It then computes new value for the whole set of provider and choose the best one according to the new po olicy. B. Implementation of Multimedia application a We have implemented the ap pplication as one main service that controls the applicattion, one service which provide the stream, and a last serrvice which displays the stream. In our situation, several streeam provider services are available with different bandwidths and resolution. There are mplementations: one is also several display service im associated with the TV, the second d one is associated with a PC, and the last one is associated with w a PDA. The Figure 5 shows the structure of the applicatio on. Media Renderer

Media Server BBC Server French Television Server

TV

Controller

CNN Server

PDA

Computer

Figure 5. Video applicatio on architecture

We have implemented the who ole application following the UPnP AV specification [8] in orrder to be able to integrate UPnP compliant media servers and d UPnP compliant media renderers. o environment provides The UPnP server available in our their bandwidth capacity and the resolution of the video r present in our stream they supply. The video renderer environment provides the maximum m resolution they are able to display. The main service of ou ur application makes the actual link between the server an nd the renderer currently used. Through the use of our framew work, we have configured the binding policy of the main seervice to connect to the media server with the best reesolution and sufficient bandwidth. Thus the utility function that is used to sort the media server can be described as: dwidth needed to actually 1. First we calculate the band provide the stream with thee claimed resolution. We associate a negative utility value v to all providers that have insufficient bandwiidth compared to the resolution of their stream.

Figure 6. Graph showiing the available bandwidth and the provider used during the experiment

2.

Then, we associate a utility value to the remaining providers corresponding to the resolution they provide and the bandwidth margin. We also have specified a utility functionn for choosing the best renderer which takes in parameter the screen resolution of the media renderer, and choose the onne which has the greater resolution. The scenario is completed by an extternal entity that manages the context aware aspects of this appplication mainly by modifying the utility function used to raank the renderer. This external entity continuously monitored the environment, and when the user is no longer alone, chhanges the utility function to privilege private display. This iss made by having a two step utility function: first, the functionn dismisses public displays, and then it sorts the private displlays according to their resolution. C. Experimental results We have implemented the application and its behavior complies with our expectations. To do that, we have launched three video stream servers, prooviding different resolution (e.g. 320x240 and 640x480) with different varying bandwidth. In order to have realistic banddwidth value, we have monitored the bandwidth of an interneet stream provider during a whole day, and we have extracted ssome very simple model from the shape of the monitored banndwidth. Then we have embedded this model in the bandwiddth simulator that we use for simulating the varying bandwidthh of video stream provider. These experiments have been done on a laptop with 2 GHz RAM and an Intel core 2 duo runningg at 2.4 GHz. The graph depicted in Figure 6, shows the avaailable bandwidth for each stream provider during the execution of the experiment, together with the actual servicce provider used. The x axis of the graph represents the timee in seconds and the vertical axis, shows the bandwidth or thhe number of the actual provider used. This graph demonnstrates that the autonomic service selection works as we eexpected and that there is no significant delay between the actual modification that lead to a reconfiguration and the linkk reconfiguration itself. To further demonstrate the main benefit of our framework, we have evaluated the ovverhead of our framework. To do that, we have comparedd the application made with our framework, with the ssame application

implemented with the iPOJO Framework without the utility function abilities. The application implemented i without our framework is able to choose neitherr the best stream provider nor the best display service. Thus, it chooses randomly one among the available providers. Thiss comparison allows us to evaluate the overhead of our framework instead of evaluating the overhead of iPOJO in addition to the one of nd footprint have already our framework. iPOJO overhead an been evaluated in (http://felix.apaache.org/site/apache-felixipojo-why-choose-ipojo.html) and are a relatively small. This experiment includes the same scenario as the previous one in which we have co ompressed the time to be able to execute the whole scenario in less than 20 seconds. We have run this scenario 500 times and the result shows an average overhead of 14% in thee execution time of the application with our self optimizatio on feature. This overhead is reasonable given the benefits of our mechanism. Further, namic environment where the experiment was set a highly dyn we have artificially increased the nu umber of reconfigurations needed in a given time interval, lead ding to an overuse of our self-optimizing mechanism. In normal condition the m smaller. overhead of our framework will be much VI.

PREVENTION OF ST TATE FLAPPING

During the experiments mention ned above which exhibit highly volatile properties such as the bandwidth, our h between providers. This framework can continuously switch is known as state flapping. It mean ns that during the time of the reconfiguration decision and th he reconfiguration itself, the best service provider may haave already changed its utility. In our application, switcching from one stream provider to another may costs (as we w have to reconnect the stream and then search for the previous p position on the stream), this problem becomes even n more important. Our technique aims to smooth the curve of the utility s past value of this function by taking into account some utility. The goal is to reduce the brutal b change of a utility function in order to avoid erratic reconfigurations. Within this have investigated three main ways of smoothing the heory: utility curve, taken from statistical th • Simple Moving Average. The first solution, we investigate was to have a sliding windows with a fixed time interval on whicch we take all the value and perform a basic averagee function.

Figure 7. Performance of the proposed damping mechanisms

•

Weighted moving average. This teechnique aims to give different weights to the differrent value of the utility function emphasizing the receent values. In this technique, the weight decrease lineaarly with the age of the utility value, meaning thaat when a value becomes out of date, its weight becoome 0. • Exponential moving average. This ttechnique has the same goal has the previous one, i.e weighing the value while performing an average function. In this technique, the weight decreases exxponentially with the age of the utility value, meaninng that all values are used in the processing, but old value have negligible weight. All these three statistical methods are well studied and have been intended to be used with the regullar observation of the value. In our case, it is a bit more compplex, because the utility values of providers are processed oonly when some provided properties are modified. Meaning that, the curve of our utility value does not contain regullar samples, but irregular one. To cope with this particularity, we havve adapted all the mathematical functions to compute the mooving average on irregular samples. Basically our adaptation ttakes into account the elapsed time between the actual valuess that we have in order to assign proper weight to each valuee. The main idea for the weighted moving average is to reeplace the linear decrease of weight by a linear decrease takking into account the elapsed time between the current time and the me idea with the observation of the value. This is the sam

exponential moving average, but in nstead of having a linear decrease, we have an exponential decrease. d Thus, two very close values in time will have simillar weight in the average processing while two far values will w have very different weights. We have evaluated the perforrmance and overhead of using such algorithms. The evalu uation was made on a random set of values in order to o assess the quality and overhead of these algorithms in a generic perspective. We nction curves using the have generated several utility fun following random model. First wee choose the time of the observation using a random timee interval between two observations varying from 10 ms to o 2 sec. We then choose the value of the utility function by b randomly choosing a difference (between -20 and +20) with the previous value. ows the overhead of each The graph presented in Figure 7 sho algorithm. In order to be able to compare c these algorithms we also have as a reference a curv ve without any damping mechanism. This graph shows on the t x axis the number of providers of the same service availlable in the environment, and on the y axis the cumulative execution time in milliseconds of our algorithm during g the experimentation. The main results show a very slight overhead for the exponential moving average while the two other techniques n our framework. This is have a very significant overhead on mainly due to the ability to incrementally compute the exponential average whereas the two others have to be ginning at each point. completely recomputed from the beg

Figuree 8. Accuracy of the proposed damping mechanisms

The two other graphs are presented in F Figure 8 show the precision and the improvement resulting from the use of these algorithms. The first graph shows thee maximum delay experimented between the actual reconfiguraation without any anti-flapping mechanism and the actual recoonfiguration with the anti-flapping mechanism. It demonnstrates that the exponential moving average gives better results than the within reasonable other techniques while keeping the delay w bounds. The second graph shows the improvvement in term of number of reconfigurations made during tthe execution. It shows that the linear moving average andd the exponential moving average provide comparable resultts while reducing the number of reconfiguration between a haalf and a third of the original number of reconfigurations. All these results demonstrate that the best flap damping algorithm is the exponential moving aveerage, because it significantly reduces the number of reconfigurations made by the framework while minimizing the overhead and maintaining an acceptable mapping bettween consumer requirements and providers used. VII. RELATED WORK Related works have already investigates the problem of finding the best matching provider acccording to QoS requirements as express by the user. Mostt of these works have been carried out with the Web Serrvice technology. These works [9] generally tackle static sselection of web services according to QoS attributes prrovided by each provider and does not really provide a self-regulating environment as the optimization is made once and never reevaluated during the whole lifecycle of thee service. Some other work [10, 11] target dynam mic environments and described algorithms to dynamicallyy select the best service provider. This work also targets thee auto-evaluation of trust of service provider, thus providing a self-regulating environment which will ignore the poor pproviders by not

using them. These works emphaasize the QoS ontology provided and the mechanism that allows the processing of the trust of each provider. They maiinly differ from our work in the sense, that we do not targett only QoS, but rather a much wider problem of service selection s and adaptation. Furthermore, none of these worrks have evaluated the performance of their algorithms, an nd they have not tried to address the problem of state flappin ng. These approaches also do not support dynamic modification n of requirements. Our work is also influenced d by other middleware research that has used utility functtions. Bhatti and Knight [12] have proposed a Quality of Service S oriented delivery mechanism for multimedia stream. Applications can specify deo stream delivery. The high level needs for audio or vid middleware transforms these req quirements to a utility functions that is used to determine th he best way to deliver the stream under the current network state. This work differs from ours because it is only taargeting the problem of multimedia stream delivery adaptaation against the current network characteristics, our solutio on is significantly more general. Rajkumar et al. [13] propose a reesource allocation system based on utility functions. App plications express their requirements in terms of CPU, memory and network ns. The system can then utilization through utility function maximize the utility of the entire system s and find the best resources repartition. This work differs d from ours ,as the system does not compute dynamiically the best resources allocation. Finally, our work was largely in nfluenced by our previous work [14]. Here middleware to retrieve contextual vironment composed of information in a smart home env various sensors is described. Ap pplications express their contextual requirements through uttility functions including QoS of the data delivered and measu ures its trust of the values returned. The system is then able to o dynamically choose and

adapt the source from which the application is retrieving the contextual information. This work differs from the one presented in this paper as it targets only event driven communication between context sources and applications, while in our work we target service oriented communication patterns. VIII. CONCLUSION In this paper, we have presented a framework oriented approach to the problem of dynamically choosing the best suited service provider for a consumer. Our approach aims to provide a self-regulating environment in which service consumers can express their needs and preferences and are automatically bound to the best available provider. This framework makes no assumption about the needs or preferences of the consumer as these are expressed through the use of utility functions that map a score to each service provider. The score of each provider is dynamically monitored and the provider used by a consumer is continuously reevaluated. We have demonstrated our framework by building a realistic scenario in the context of the residential computing whereby out application aims to provide video to the user on one of the available media systems in the home. Through this application, we have demonstrated the accuracy of our framework while also evaluating the performance. The results show the very low overhead compared to the same application without this self-optimizing mechanism. During this experiment we have noticed that providing such optimization algorithm in a highly dynamic environment can imply an increasing number of reconfigurations leading to a decrease in performance. This state flapping motivated the introduction of mechanisms to dampen these system oscillations. We have evaluated the performance of each mechanism and demonstrated that using an exponential moving average can significantly reduce the overall oscillation of the system while minimizing the overhead induced by the use of such mechanism. In our future work, we aim at investigating other types of mechanisms to dampen the system oscillation such as: • Soft threshold. The main goal of this technique is to determine a range of values around the current best utility. If another provider becomes better but its utility value stays within this interval, the framework does not actually change the used provider. The basic idea is to change provider only when it really worth the change. • Authorized reconfiguration points. This technique aims to allow link reconfiguration only at a certain

point of the service execution. For example it may not be a good thing to modify the service provider used in the middle of a state full conversation. Intuitively, this technique can limit the number of reconfigurations when these reconfigurations are costly, and let all the reconfigurations take place, when they do not impact the execution of the requesting service. We are also interested in going further in the selfregulating environment direction in order to apply some mechanisms to automatically and dynamically evaluate the trust of service providers in order to be able to takes it into account consumer preference and requirements. IX. [1]

[2]

[3]

[4] [5]

[6] [7]

[8] [9]

[10]

[11]

[12] [13]

[14]

REFERENCES

M. P. Papazoglou, P. Traverso, S. Dustdar, and F. Leymann, "Service-Oriented Computing: State of the Art and Research Challenges," IEEE Computer, vol. 40, p. 8, 2007. C. Escoffier, J. Bourcier, and P. Lalanda, "Towards a home application server," in IEEE Consumer Communications and Networking Conference (CCNC’08), Las Vegas, 2008. A. Bottaro, J. Bourcier, C. Escoffier, and P. Lalanda, "Context-Aware Service Composition in a Home Control Gateway," in Pervasive Services, IEEE International Conference on, 2007, pp. 223-231. UPnP Plug and Play Forum, "About the UPnP Plug adn Play Forum," in http://www.upnp.org/, 1999. SUN, "Jini Technology Architectural Overview," in http://www.sun.com/software/jini/whitepapers/architecture.html, 1999. OSGi Alliance, "OSGi Service Platform Core Specification," OSGi Alliance: http://osgi.org, 2005. C. Escoffier, R. S. Hall, and P. Lalanda, "iPOJO An extensible service-oriented component framework," in IEEE Service Computing Conference, Salt Lake City, 2007. UPnPTM Forum, “UPnPTM AV Architecture 1.0”, September 2008. Tao Yu and Kwei-Jay Lin, “Service Selection Algorithms for Composing Complex Services with Multiple QoS Constraints”, Service-Oriented Computing - ICSOC 2005, Amsterdam, 2005 E. M. Maximilien, M. P. Singh, “Toward Autonomic Web Services Trust and Selection”, Service-Oriented Computing - ICSOC 2004, New York, 2004 Y Liu, A. Ngu, L. Zeng, “QoS computation and policing in dynamic web service selection”, International World Wide Web Conference, New York, 2004 S. N. Bhatti and G. Knight, “Enabling QoS Adaptation Decisions for Internet Applications”, Computer Networks, 31(7):669-692, 1999 R. Rajkumar, C. Lee, J. Lehoczky, D. Siewiorek, “A Resource Allocation Model for QoS Management” IEEE Real Time Systems Symposium (RTSS’97), 1997 M. C. Huebscher, J. A. McCann, “An adaptative middleware framework for context-aware applications” Springer Personal and ubiquituous Computing Journal, Volume 10, Number 1, pp. 12-20, 2005