Mauro Iacono

The OsMoSys approach to multi-formalism modeling of systems

Analysis and simulation of complex systems are facilitated by the availability of appropriate modeling formalisms and tools. In many cases, no single analysis and modeling method can successfully cope with all aspects of a complex system: a multi-formalism multi-solution approach is very appealing, since it offers the possibility of applying the most suitable formalisms and solution techniques to model and analyze different components or aspects of a system. Another important feature that a successfull modeling approach should include is the possibility of reusing (sub)models: by composing parameterized submodels and then instantiating the parameters, complete models of different scenarios can be obtained and analyzed.This paper introduces an innovative approach to multi-formalism modeling of systems that is part of the OsMoSys (Object-based multi-formaliSm MOdeling of SYStems) framework. OsMoSys uses the proposed modeling approach to build multi-formalism models, and workflow management to achieve multi-solution. Our modeling approach is based on meta-modeling, allowing to easily define and integrate different formalisms, and on some concepts from object orientation. Its main objectives are the interoperability of different formalisms and the definition of mechanisms to guarantee the flexibility and the scalability of the modeling framework.

Performance evaluation of NoSQL big-data applications using multi-formalism models

Abstract Starting with the birth of Web 2.0, the quantity of data managed by large-scale web services has grown exponentially, posing new challenges and infrastructure requirements. This has led to new programming paradigms and architectural choices, such as map-reduce and NoSQL databases, which constitute two of the main peculiarities of the specialized massively distributed systems referred to as Big Data architectures. The underlying computer infrastructures usually face complexity requirements, resulting from the need for efficiency and speed in computing over huge evolving data sets. This is achieved by taking advantage from the features of new technologies, such as the automatic scaling and replica provisioning of Cloud environments. Although performances are a key issue for the considered applications, few performance evaluation results are currently available in this field. In this work we focus on investigating how a Big Data application designer can evaluate the performances of applications exploiting the Apache Hive query language for NoSQL databases, built over a Apache Hadoop map-reduce infrastructure. This paper presents a dedicated modeling language and an application, showing first how it is possible to ease the modeling process and second how the semantic gap between modeling logic and the domain can be reduced, by means of vertical multiformalism modeling.

Repairable fault tree for the automatic evaluation of repair policies

Fault trees are a well known mean for the evaluation of dependability of complex systems. Many extensions have been proposed to the original formalism in order to enhance the advantages of fault tree analysis for the design and assessment of systems. In this paper we propose an extension, repairable fault trees, which allows the designer to evaluate the effects of different repair policies on a repairable system: this extended formalism has been integrated in a multi-formalism multi-solution framework, and it is supported by a solution technique which transparently exploits generalized stochastic Petri nets (GSPN)for modelling the repairing process. The modelling technique and the solution process are illustrated through an example.

Interfaces and binding in component based development of formal models

Component based modeling is of great importance for building and analyzing models of real systems. It is based on a well known paradigm which makes use of abstraction and composition. In this paper we focus on abstraction, by describing a practical approach to the definition of very simple interface models allowing the substitution of components within composed multiformalism models. The work extends the OsMoSys methodology and relies on meta-modeling. This paper does not discuss formal aspects about interface theory and components interaction, but focuses on the problem of building component models in practice with the ultimate goal of solving them by using (the existing) analysis tools. The paper formally extends the OsMoSys conceptual model in order to introduce model interfaces and to provide some rules for interface compatibility. The paper also describes some steps towards the full definition of mechanisms for interface binding and their implementation.

Modeling performances of concurrent big data applications

Big Data applications are characterized by a non‐negligible number of complex parallel transactions on a huge amount of data that continuously varies, generally increasing over time. Because of the amount of needed resources, the ideal runtime scenario for these applications is based on complex cloud computing and storage infrastructures, providing a scalable degree of parallelism together with isolation between different applications and resource abstraction. However, such additional abstraction degree also introduces significant complexity in performance modeling and decision making. Potential concurrency of many applications on the same cloud infrastructure has to be evaluated, and, simultaneously, scalability of applications over time has to be studied through proper modeling practices, in order to predict the system behavior as the usage patterns evolve and the load increases. For this purpose, in this paper, we propose an analytic modeling technique based on the use of Markovian Agents and Mean Field Analysis that allows the effective description of different concurrent Big Data applications on a same, multi‐site cloud infrastructure, accounting for mutual interactions, in order to support the careful evaluation of several elements in terms of real costs/risks/benefits for correctly dimensioning and allocating the resources and verifying the existing service level agreements. Copyright

Exploiting product forms solution techniques in multiformalism modeling

Multiformalism modeling has shown to be a valuable technique to cope with the complexity of the constraints that apply to specifications of computer-based systems state of the art. Multiformalism techniques help modelers and designers by providing a more (natural and) convenient approach in the specification process and in analysis of performance. Although their application does not necessarily provide an advantage in the solutions of the models, this paper shows how a compositional multiformalism modeling approach can leverage the power of product-form solutions to offer both efficient solution and specification of models for complex systems.

The SIMTHESys multiformalism modeling framework

The usage of models is a fundamental activity in designing and verifying a system. Mastering different modeling techniques and scaling their application to complex systems is not an easy task and requires both advanced skills and proper tools. One of the means that allow modelers to leverage the power of proper modeling techniques (e.g. stochastic techniques) is the application of abstractions by using high level formal modeling languages. This paper presents SIMTHESys, a framework for the development of formal modeling languages and the solution of multiformalism models by automatically generated solvers based on different solving engines.

Using repairable fault trees for the evaluation of design choices for critical repairable systems

Critical repairable systems are characterized by complex architecture and requirements. The evaluation of benefits produced by repair policies on the overall system availability is not straightforward, as policies can be very articulated and different. In order to support this evaluation process, the repairable fault tree (RFT) formalism revealed to be useful and suitable to represent complex repair policies by extending the existing fault tree formalism. In this paper we show how to exploit RFT advantages by evaluating the effects of different repair policies on the availability of the most critical component of ERTMS/ETCS (an European railway standard) systems: the radio block centre (RBC).

Defining Formalisms for Performance Evaluation With SIMTHESys

Tools for the analysis and modeling of complex systems must be able to support the extensibility of formalisms, reusability of models and customization of formalism compositions. From this perspective, SIMTHESys (Structured Infrastructure for Multiformalism modeling and Testing of Heterogeneous formalisms and Extensions for SYStems) is a new approach to the specification of performability oriented formalisms and the evaluation of models. Its originality emerges from the explicit definition of both syntax and evolution semantics of the considered formalism elements. The solution of models is made possible by using a set of non-specialized solving engines used to generate automatically formalism-specific reusable solvers. This paper explains how formalisms can be created in SIMTHESys by showing how three widely known modeling languages are successfully implemented.

A Performance Modeling Language For Big Data Architectures.

Big Data applications represent an emerging field, which have proved to be crucial in business intelligence and in massive data management. Big Data promises to be the next big thing in the development of strategical computer applications, even if it requires considerable investment and an accurate resource planning, as the architectures needed to perform at the requisite speed need to scale easily on to a large number of computing nodes. Appropriate management of such architectures benefits from the availability of performance models, to allow developers and administrators to take informed decisions, saving time and experimental work. This paper presents a dedicated modeling language showing firstly how it is possible to ease the modeling process and secondly how the semantic gap between modeling logic and the domain can be reduced.