@conference {jopera:2008:icac, title = {Automatic Configuration of an Autonomic Controller: An Experimental Study with Zero-Configuration Policies}, booktitle = {5th International Conference on Autonomic Computing (ICAC 2008)}, year = {2008}, month = {June}, pages = {67-76}, publisher = {IEEE}, organization = {IEEE}, address = {Chicago, IL, USA}, abstract = {Autonomic control managers can remove the need for manual system configuration in order to achieve good performance and efficient resource utilization. However, simple controllers based on reconfiguration actions tied to thresholds, or {\textquoteright}if-then{\textquoteright} rules, themselves need to be configured and tuned in order to adapt the controller behavior to the expected workload characteristic. In this paper we present an experimental study of zero-configuration policies that can be automatically tuned based on analytical models of the system under control. In particular, we have designed and implemented a threshold-free self-configuration policy for a distributed workflow execution engine and compared it with a standard PID controller. The experimental results included in the paper show that using such a policy the controller can tune itself in addition to reconfiguring the distributed engine and the proposed policy out-performs simpler policies that require manual and error-prone tuning of their parameters.}, keywords = {analytical models, automatic configuration, automatic control, autonomic controller, control system synthesis, distributed workflow execution engine, PID control, resource management, resource utilization, workload characteristic, zero-configuration policies}, doi = {10.1109/ICAC.2008.29}, author = {Thomas Heinis and Cesare Pautasso} } @article {jopjauto07, title = {Autonomic resource provisioning for software business processes}, journal = {Information and Software Technology}, volume = {49}, year = {2007}, month = {January}, pages = {65-80}, abstract = {Software development nowadays involves several levels of abstraction: starting from the programming of single objects, to their combination into components, to their publication as services and the overall architecture linking elements at each level. As a result, software engineering is dealing with a wider range of artifacts and concepts (i.e., in the context of this paper: services and business processes) than ever before. In this paper we explore the importance of having an adequate engine for executing business processes written as compositions of Web services. The paper shows that, independently of the composition language used, the overall scalability of the system is determined by how the run-time engine treats the process execution. This is particularly relevant at the service level because publishing a process through a Web service interface makes it accessible to an unpredictable and potentially very large number of clients. As a consequence, the process developer is confronted with the difficult question of resource provisioning. Determining the optimal configuration of the distributed engine that runs the process becomes sensitive both to the actual number of clients and to the kinds of processes to be executed. The main contribution of the paper is to show how resource provisioning for software business processes can be solved using autonomic computing techniques. The engine separates execution in two stages (navigation and dispatching) and uses a controller to allocate the node of a cluster of computers to each one of those stages as the workload changes. The controller can be configured with different policies that define how to reconfigure the system. To prove the feasibility of the concept, we have implemented the autonomic controller and evaluated its performance with an extensive set of experiments.}, keywords = {autonomic computing, distributed business process execution engines, service oriented architectures, Web service composition}, doi = {10.1016/j.infsof.2006.08.010}, author = {Cesare Pautasso and Thomas Heinis and Gustavo Alonso} } @article {119, title = {Developing scientific workflows from heterogeneous services}, journal = {SIGMOD Rec.}, volume = {35}, year = {2006}, month = {June}, pages = {22{\textendash}28}, abstract = {Scientific Workflows (SWFs) need to utilize components and applications in order to satisfy the requirements of specific workflow tasks. Technology trends in software development signify a move from component-based to service-oriented approach, therefore SWF will inevitably need appropriate tools to discover and integrate heterogeneous services. In this paper we present the SODIUM platform consisting of a set of languages and tools as well as related middleware, for the development and execution of scientific workflows composed of heterogeneous services.}, keywords = {JOpera, scientific workflow management}, issn = {0163-5808}, doi = {10.1145/1147376.1147380}, author = {Aphrodite Tsalgatidou and Georgios Athanasopoulos and Michael Pantazoglou and Cesare Pautasso and Thomas Heinis and Roy Gr{\o}nmo and Hoff Hj{\o}rdis and Arne-J{\o}rgen Berre and Magne Glittum and Simela Topouzidou} } @article {117, title = {JOpera: Autonomic Service Orchestration}, journal = {IEEE Data Engineering Bulletin}, volume = {29}, year = {2006}, month = {September}, pages = {32-39}, keywords = {autonomic computing, JOpera, Web service composition}, url = {ftp://ftp.research.microsoft.com/pub/debull/A06sept/issue1.htm}, author = {Cesare Pautasso and Thomas Heinis and Gustavo Alonso} } @conference {jopera:2006:ccgrid, title = {Mirroring Resources or Mapping Requests: implementing WS-RF for Grid workflows}, booktitle = {6th IEEE International Symposium on Cluster Computing and the Grid (CCGrid2006)}, year = {2006}, month = {May}, address = {Singapore}, abstract = {The Web Services Resource Framework (WS-RF) and the Web Services Notification (WS-N) specifications are a crucial component of Grid infrastructures. They provide a standardized interface to stateful services so that they can be managed remotely. There are already several implementations of these specifications and initial performance studies have compared them in terms of the overhead observed by a single client. In this paper we address the problem of implementing the WS-RF and WS-N specifications for large scale systems. In particular, we discuss how to implement WS-RF and WSN as the management interfaces to a Grid workflow engine. In the paper we describe and compare two different architectures for mapping resources to processes. The first one mirrors the state of the process as a resource. The second one maps the client requests to access the state of a resource embedded into the Grid workflow engine. We include an extensive performance evaluation, comparing the resulting systems in terms of scalability when servicing a large number of concurrent clients. }, keywords = {grid computing, JOpera, scientific workflow management}, doi = {10.1109/CCGRID.2006.69}, author = {Thomas Heinis and Cesare Pautasso and Gustavo Alonso} } @inbook {jopera:2006:acbook, title = {A Self-Configuring Service Composition Engine}, booktitle = {Autonomic Computing: Concepts, Infrastructure, and Applications}, year = {2006}, pages = {237-252}, publisher = {CRC Press}, organization = {CRC Press}, chapter = {12}, keywords = {autonomic computing}, isbn = {0-8493-9367-1}, doi = {10.1201/9781420009354.ch12}, author = {Thomas Heinis and Cesare Pautasso and Gustavo Alonso}, editor = {Manish Parashar and Salim Hariri} } @conference {jopera:2005:icws, title = {Autonomic Execution of Service Compositions}, booktitle = {3rd International Conference on Web Services (ICWS 2005)}, year = {2005}, month = {July}, publisher = {IEEE}, organization = {IEEE}, address = {Orlando, Florida}, abstract = {An increasing amount of Web services are being implemented using process management tools and languages (BPML, BPEL, etc.). The main advantage of processes is that designers can express complex business conversations at a high level of abstraction, even reusing standardized business protocols. The downside is that the infrastructure behind the Web service becomes more complex. This is particularly critical for Web services that may be subjected to high variability in demand and suffer from unpredictable peaks of heavy load. In this paper we present a flexible architecture for process execution that has been designed to support autonomic scalability. The system runs on a cluster of computers and reacts to workload variations by altering its configuration in order to optimally use the available resources. Such changes happen automatically and without any human intervention. This feature completely removes the need for the manual monitoring and reconfiguration of the system, which in practice is a difficult and time-consuming operation. In the paper we describe the architecture of the system and present an extensive performance evaluation of its autonomic capabilities.}, keywords = {autonomic computing, JOpera, Web service composition}, doi = {10.1109/ICWS.2005.28}, author = {Cesare Pautasso and Thomas Heinis and Gustavo Alonso} } @conference {jopera:2005:icac, title = {Design and Evaluation of an Autonomic Workflow Engine}, booktitle = {2nd International Conference on Autonomic Computing (ICAC-05)}, year = {2005}, month = {June}, pages = {27 - 38}, publisher = {IEEE}, organization = {IEEE}, address = {Seattle, Washington}, abstract = {In this paper we present the design and evaluate the performance of an autonomic workflow execution engine. Although there exist many distributed workflow engines, in practice, it remains a difficult problem to deploy such systems in an optimal configuration. Furthermore, when facing an unpredictable workload with high variability, manual reconfiguration is not an option. Thanks to its autonomic controller, the engine features self-configuration, self-tuning and self-healing properties. The engine runs on a cluster of computers using a tuple space to coordinate its various components. Its autonomic controller monitors its performance and responds to workload variations by altering the configuration. In case failures occur, the controller can recover the workflow execution state from persistent storage and migrate it to a different node of the cluster. Such interventions are carried out without any human supervision. As part of the results of our performance evaluation, we compare different autonomic control strategies and discuss how they can automatically tune the system}, keywords = {automatic configuration, autonomic computing, JOpera, Web service composition}, doi = {10.1109/ICAC.2005.21}, author = {Thomas Heinis and Cesare Pautasso and Gustavo Alonso} } @conference {jopera:2005:escience, title = {Publishing Persistent Grid Computations as WS Resources}, booktitle = {1st IEEE International Conference on e-Science and Grid Computing (e-Science 2005)}, year = {2005}, month = {December}, publisher = {IEEE}, organization = {IEEE}, address = {Melbourne, Australia}, abstract = {Grid services can be composed into processes, providing a high level definition of the computations involved in terms of their data exchanges and control flow dependencies. We show how processes themselves can be efficiently published as Grid services by mapping the persistent state of the process executions to standard compliant interfaces as defined by the Web Services Resource Framework (WS-RF). Mapping processes to resources is a fundamental step to enable recursive Grid service composition, where composite Grid services are themselves published as services. This gives processes a standardized and wellunderstood interface that enables their management, monitoring, steering and adaptation. Additionally it eases their reusability and simplifies integration into existing Grid applications and portals. In order to determine the mapping{\textquoteright}s overhead, we include the results of a comprehensive performance evaluation.}, keywords = {grid computing, JOpera, scientific workflow management}, doi = {10.1109/E-SCIENCE.2005.67}, author = {Thomas Heinis and Cesare Pautasso and Oliver Deak and Gustavo Alonso} }