MODELING AND SIMULATION OF COMPUTER NETWORKS AND SYSTEMS

MODELING AND SIMULATION OF COMPUTER NETWORKS AND SYSTEMS: METHODOLOGIES AND APPLICATIONS A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Paolo Bocciarelli and Andrea D’Ambrogio

2 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Introduction Service-Oriented Architecture (SOA) is a widely used software building paradigm, according to which an application results from the orchestration of a set of services in execution onto networked server hosts A service can be seen as an open and self-describing component providing a welldefined set of operations Web Services is the most used technology for implementing the service concept Service-oriented software systems are often at the core of mission- or businesscritical systems thus advanced quantitative analysis techniques are needed to assess, from the early development stages, whether or not the system accomplishes the stakeholder requirements and constraints In this respect, simulation is an effective and widely adopted approach for carrying out a quantitative early evaluation of the system behavior

3 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Introduction (cont. d) Simulation-based techniques provide a valuable strategy both to cut the cost of developing experimental prototypes and to mitigate the risk of time/cost overrun due to re-design and re-engineering a system that does not provide the required quality Simulation-based analysis requires to: first build a simulation model of the system then implement the model into a simulation program and finally execute the program to obtain the results that allow one to analyze the performance of a system Various paradigms may be used to carry-out the simulation execution, according to the characteristics of the execution platform

4 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Simulation execution paradigms Local Simulation (LS) Parallel Simulation (PS) the simulation program is deployed onto a single processor platform that completes its execution the simulation program is executed on top of a multiprocessor computing platform containing multiple CPUs that interact frequently, e. g. , thousands of times per second Distributed Simulation (DS) – addressed in this chapter the simulation program is executed on loosely coupled computing platforms, in which interactions take much more time, e. g. , milliseconds or more, and occur less often. Its execution relies on a distributed system consisting of a set of hosts interconnected through a LAN or a WAN (e. g. , the Internet) network infrastructure

5 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Distributed Simulation Distributed simulation (DS) naturally addresses the inherent complexity and the distributed nature of service-oriented software systems A DS is built by integrating into a so called federation the several simulation components (i. e. , the federates) that are executed onto a set of nodes interconnected by a network infrastructure of LAN or WAN type DS has been traditionally used as a means to achieve scalability, reusability and parallelism Nevertheless, the adoption of DS techniques requires a significant expertise and a considerable effort, due to the complexity of currently available DS standard and technologies

6 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Chapter contribution To reduce the effort and make DS easier to use, this chapter introduces a modeldriven automated method for enacting at design-time the DS-based performance analysis of service-oriented software systems The proposed method consists of two model transformations that take as initial input the UML (Unified Modeling Language) model of the system under study, generate the corresponding performance-oriented DS model and, finally, yield as final output the DS code ready to be executed Specifically, this work adopts the EQN (Extended Queueing Network) formalism to define the (DS-based) performance model and makes use of the j. EQN language to implement and execute the performance model j. EQN is part of Sim. Arch, a layered architecture that eases the use of DS techniques by hiding all the implementation details of the distributed execution platform

7 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Chapter contribution (cont. d) Model transformations have been implemented according to principles and standards introduced in the model-driven engineering field The method makes use of MDA (Model Driven Architecture), the Object Management Group’s incarnation of model-driven engineering principles MDA-based software development is founded on the principle that a system can be built by specifying a set of model transformations, which allow to obtain models at lower abstraction levels from models at higher abstraction levels To achieve such an objective, MDA provides the following standards: Meta Object Facility (MOF): for specifying technology neutral metamodels (i. e. , models used to describe other models) XML Metadata Interchange (XMI): for serializing MOF metamodels/models into XML-based schemas/documents Query/View/Transformation (QVT): for specifying model transformations

8 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems MDA in a nutshell

9 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Sim. Arch and j. EQN Sim. Arch is a layered architecture that eases the development of local and distributed simulation systems by raising the developers from all the details concerning the execution environment, which can be either a conventional local execution platform or a distributed execution platform, e. g. , one based on the HLA (High Level Architecture) standard The simulation model is specified in terms of the adopted domain-specific language (DSL), defined at the upper layer of Sim. Arch This work exploits the j. EQN language, a DSL for the specification of the EQN models

10 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems j. EQN Based on: Domain analysis of EQN models Declarative approach (specify what to simulate rather then how to simulate) Used to: Reduce the semantic gap between the model specification and the corresponding LS/DS system Composed of: Simulation services defined by Sim. Arch Set of EQN simulation components Set of parameters for the components

11 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems j. EQN simulation architecture

12 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Model-driven method

13 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems UML profiles and Q-WSDL The input UML model is annotated with stereotypes provided by the UML profile for the Service oriented architecture Modeling Language (Soa. ML) Moreover, the UML Profile for Modeling and Analysis of Real-Time Embedded systems (MARTE) is also used to characterize the input UML model in terms of performance-related properties and requirements In a SOA, services are described by use of WSDL (Web Service Description Language) documents Unfortunately, a WSDL document only addresses the functional aspects of a Web service. Different Web services may provide similar functionality, but with distinct non-functional (e. g. , performance-oriented) properties To this purpose, the model-driven method discussed in this chapter makes use of Q-WSDL (Quality-enabled WSDL), a lightweight WSDL extension for the description of the performance properties of a Web service

14 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems EQN metamodel

15 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Method implementation - UML-to-EQN model-to-model transformation (specified in QVT/Operational Mappings)

16 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Method implementation – EQN parameterization

17 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Method implementation - EQN-to-j. EQN model-to-text transformation (specified in MOFM 2 T) Step 1 Step 2 generation of simulation scenario settings; Step 3 generation of both the software components managing the execution of the distributed simulation systems and the data structures exchanged by simulation components; generation of j. EQN simulation components, according to the EQN partitioning; Step 4 generation of the batch file to start the Java programs containing the j. EQN components.

18 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Method implementation - EQN-to-j. EQN transformation – Step 3 3. 1 Generation of import statements and Class skeleton 3. 2. Generation of main method 3. 2. 1. Generation of statements for Sim. Arch and j. EQN initialization 3. 2. 2. Generation of statements for the subnetwork’s EQN (local) entities 3. 2. 3. Generation of statements for the remote stubs for adjacent subnetwork’s EQN entities 3. 2. 4. Generation of statements for the connections of the declared entities (both local and remote stubs) 3. 2. 5. Generation of the statements to activate the simulation execution

19 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Method implementation - EQN-to-j. EQN transformation – Mapping of EQN to j. EQN (for each subnetwork)

20 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Example Application – Car Reservation Service-oriented application for reserving cars provided by a car sharing company. Let us suppose that the reservation process includes the following main steps 1. the user provides the authentication credentials 2. according to the existing user profile, the system retrieves and shows to the user a set tailored commercial offers. The system also shows on a map the location of available cars ready for renting 3. the user selects the car to be rented 4. the system retrieves and shows the list of fuel stations and parking areas 5. the user confirms the reservation As regards step 4, it is assumed that with a 70% probability the user prefers a public parking area. Depending to the user’s choice the system retrieves and shows the desired type of parking

21 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Example Application – Service Interfaces and Capabilities

22 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Example Application – Participants

23 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Example Application – Service Contracts

24 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Example Application – Composite Structure Diagram

25 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Example Application – Annotated AD (requirements)

26 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Example Application – Annotated AD (service capabilities)

27 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Example Application – EQN model with subnets partitioning

28 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Example Application – Fragment of j. EQN code

29 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Example Application – Results of the performance prediction

30 A Model-driven Method for the Design-time Performance Analysis of Service-Oriented Software Systems Conclusions This chapter has introduced a model-driven method to automate the design time performance analysis of service-oriented systems The method makes use of a distributed simulation approach that, differently from conventional (i. e. , local) simulation approaches, replicates the distributed architecture of the addressed systems and provides several advantages, the most relevant ones being the increased computational capability and the ability to reuse and integrate already existing simulation components The proposed method consists of a two model transformations that take as initial input the UML model of the system under study and yield as final output the Java code of the distributed simulation based on the j. EQN domain specific language and the Sim. Arch architecture The execution of the so-obtained simulation code allows to predict the system behavior and obtain the required performance-related indices An example application has been provided, to show the proposed method can be easily used even by software analysts who are not familiar with performance theory and/or distributed simulation standard and technologies.