Roberto Torella

A Simulation-Based Framework for Autonomic Web Services

A possible solution to guarantee critical requirements in Web services designs is the use of an autonomic architecture, able to auto-configure and to auto-tune. This paper presents an innovative approach for the development of self-optimizing autonomic systems for Web services architectures, based on the adoption of a simulation engine for obtaining performance predictions. MAWeS (MetaPL/HeSSE Autonomic Web Services) is a framework whose aim is to support the development of self-optimizing predictive autonomic systems for Web service architectures. It adopts a simulation-based methodology, which allows to predict system performances in different status and load conditions. The predicted results are used for a feedforward control of the system, which self-tunes before the new conditions and the subsequent performance losses are actually observed

Performance-driven development of a Web services application using MetaPL/HeSSE

One of the leading programming techniques for the development of distributed applications is the use of Web services (WS). The strong point of WS technology is the definition of an operating environment that can be adopted to execute applications, independently of the original development and deployment platforms. However, whenever performance is an issue, the message overhead resulting from the XML messaging approach and from the software layers introduced to obtain system abstraction should be carefully considered. This paper presents a simulation-based methodology that makes it possible to predict Web services-based application performance, even if the execution environment of choice is not available and the application is not completely developed. This methodology can be used as the basis for performance-driven Web services development. The proposed methodology is applied to the development of a simple but realistic Web service application.

Cluster systems and simulation: from benchmarking to off‐line performance prediction

This paper describes a simulation‐based technique for the performance prediction of message‐passing applications on cluster systems by means of benchmark data. Given data measuring the performance of a target cluster in the form of standard benchmark results, along with the details of the chosen computing configuration, it is possible to build and to validate automatically a detailed simulation model. This makes it possible to predict off‐line, i.e. without resorting to the real hardware, the performance of fully developed or even of skeletal code. An XML‐based language (MetaPL) is adopted to describe the application behavior in the development stage. After a description of the approach and the illustration of the construction and validation of the simulation model, the paper presents a case study. Copyright

Off-line performance prediction of message-passing applications on cluster systems

This paper describes a simulation-based technique for the performance prediction of message- passing applications on cluster systems. Given data measuring the performance of a target cluster in the form of standard benchmark results, along with the details of the chosen computing configuration (e.g., the number of nodes), it is possible to build and to validate automatically a detailed simulation model. This makes it possible to predict the performance of fully-developed or skeletal code off-line, i.e., without resorting to the real hardware. The reasonable accuracy obtained makes this approach particularly useful for preliminary performance testing of parallel code on non-available hardware. After a description of the approach and of the construction and validation of the simulation model, the paper presents a case study.

Self-optimizing MPI applications: a simulation-based approach

Historically, high performance systems use schedulers and intelligent resource managers in order to optimize system usage and application performance. Most of the times, applications just issue requests of resources to the central system. This centralized approach is an unnecessary constraint for a class of potentially flexible applications, whose resource usage may be modulated as a function of the system status. In this paper we propose a tool which, in a way essentially transparent to final users, lets the application to self-tune in function of the status of the target execution environment. The approach hinges on the use of the MetaPL/HeSSE methodology, i.e., on the use of simulation to predict execution times and skeletal descriptions of the application to describe run-time resource usage.

A performance-oriented technique for hybrid application development

In SMP clusters it is not always convenient to switch from pure message-passing code to hybrid software designs that exploit shared memory. This paper tackles the problem of restructuring an existing MPI code through the insertion of OpenMP directives. The choice of the best code is carried out with a performance-oriented approach, predicting the effect of application hybridization in the MetaPL/HeSSE simulation environment, without writing and running any hybrid software. The technique is validated by applying the devised changes to the code, and comparing the predicted results to actual running time measurements.