Leandro Dias da Silva

Ticc: a tool for interface compatibility and composition

We present the tool Ticc (Tool for Interface Compatibility and Composition). In Ticc, a component interface describes both the behavior of a component, and the components assumptions on the environments behavior. Ticc can check the compatibility of such interfaces, and analyze their emergent behavior, via a symbolic implementation of game-theoretic algorithms.

Invited contribution : sociable interfaces

Interface formalisms are able to model both the input requirements and the output behavior of system components; they support both bottom-up component-based design, and top-down design refinement. In this paper, we propose “sociable” interface formalisms, endowed with a rich compositional semantics that facilitates their use in design and modeling. Specifically, we introduce interface models that can communicate via both actions and shared variables, and where communication and synchronization covers the full spectrum, from one-to-one, to one-to-many, many-to-one, and many-to-many. Thanks to the expressive power of interface formalisms, this rich compositional semantics can be realized in an economical way, on the basis of a few basic principles. We show how the algorithms for composing, checking the compatibility, and refining the resulting sociable interfaces can be implemented symbolically, leading to efficient implementations.

Composition of software artifacts modelled using colored Petri nets

In this work we introduce a new formal model for software components supporting behavioral interpretability based on temporal logic, Petri nets, model checking, and an assume-guarantee strategy to specify and reason about the composition of concurrent component systems. The formal specification and verification strategies, methods, and techniques presented in this work contribute to the development of more dependable component-based software systems, in a modular way. An approach based on two complementary formalisms, Hierarchical Colored Petri Nets (HCPN) and temporal logic, is introduced. HCPN are used to visualize the structure and model the behavior of software architectures and components, and temporal logic is used to specify the required properties of software architectures and component interfaces.

Formal modelling and verification of a component model using coloured petri nets and model checking

Component based software engineering has been claimed as a suitable approach to improve the flexibility and reuse in software development. In this context, the Compor infrastructure provides mechanisms to promote the dynamic composition of software systems, addressing applications with support for unanticipated requirement changes. In this paper, the formal modelling and verification of the COMPOR component model is presented. Hierarchical Colored Petri Nets are used for modelling and simulation, purposing to show the correct behavior for some scenarios. Model checking is used to prove that the scenarios analyzed with simulation are correct for all possible behaviors of the model.

A formal approach for the modelling and verification of multiagent plans based on model checking and petri nets

Multiagent systems are characterized by decentralized control and agents that perform autonomous actions. The sequence of such actions are generally described by plans. An important issue in this context is how to verify the correctness of plans when agents have unpredicted actions. In this paper, formal modelling and verification guidelines to verify nondeterministic multiagent system plans are introduced. The guidelines are based on HCPN modelling, simulation, and model checking. The guidelines are conceptually introduced, and then applied for a multiagent intelligent tutoring system modelling and verification.

Formal specification of DSP gateway for data transmission between processor cores of OMAP platform

In this article, formal models for the data transmission mechanism between ARM and DSP cores of OMAP platform 161x via DSP Gateway are presented. These models are represented as timed automata. The automata for the behavior of tasks running in the DSP when receiving requests of read or write operations from ARM are described. Data transmission between ARM and DSP is modelled according to the mechanism offered by tokliBIOS, the system kernel at DSP side. The formal model presented in this work helps developers to understand the communication mechanisms of DSP Gateway and facilitates its usage and future development.

A Systematic and Formal Approach to the Specification of Flexible Manufacturing Systems Reusing Coloured Petri Nets Models

Abstract In this work a systematic methodology to reuse Coloured Petri Nets models is described. The methodology is applied to the flexible manufacturing systems domain. A model of a system can be developed reusing parts of previous designs, instead of modeling always from the scratch. The phases of reuse considered in this work are recovery, adaptation, integration, and use verification. We define an automatic integration approach, based on an architectural framework to build new models. The use verification phase is also defined to verify whether the new model do not violate the semantics of the reused models.

Model-Based Solution for Controlling Physiology

In 2008, 63% of the estimated global deaths was due to non-communicable diseases (NCD). One of the main known NCD behavioral risk factors is physical inactivity. Daily physical activity allows controlling weight, reducing NCD death risks. However, irresponsible practice of physical activities can harm both healthy and unhealthy people due to physiological disturbance. In this paper a model-based solution is presented for controlling human physiology during exercise. The presence of non-invasive sensors for collecting physiological data periodically is assumed. Such data is evaluated in comparison to a supervised reference model built using a formal language. Some challenges are also outlined.

Using equivalence classes for testing programs for safety instrumented systems

The reliability on Safety Instrumented Systems (SIS) is critical for the safe operation of many industrial applications. In particular, SIS play an important role in oil and gas processing plants. SIS are responsible not only for the continuous operation of the plant, it also keeps the plant in a safe state, avoiding damages to the environment and minimizing risks to employees. Therefore, the correct behavior of such systems is an important goal to achieve when building industrial plants. Verification and testing of SIS programs is a very hard task to accomplish. This happens mainly for two reasons. First, testing the real system is very expensive and sometimes it may take a huge amount of time, weeks or even months. Second, those systems deal with a huge number of variables. It is not always possible for a human tester to check if all of them are correct when performing tests. Providing an automatic and formal testing approach for such systems is an important contribution for the development of such systems. In this work we introduce a new method for generating test cases for SIS programs running on Programable Logic Controller (PLC). As we did on previous work, ISA 5.2 diagrams are used as specification of the systems, but now we are using a hardware-in-the-loop technique, and the target artifact is a software running on a PLC. To avoid the execution of redundant tests, we introduced a new test case generation algorithm that is based on equivalence classes. Finally, we discussed a study case in which our method is used to detect error, that were introduced on purpose, on a simple system.

Petri Nets for Component-Based Software Systems Development

The Software Engineering discipline was created to try to apply techniques and methods of others engineering disciplines to software systems development. To achieve this goal it was necessary to change the way software was developed, not only at code level, but also at the process level. Like in other engineering disciplines, one of the major objectives of software engineering is to develop artifacts in a systematic way. Several building block approaches were proposed and developed along the years. Nowadays one of the most researched and used approach are software components (Crnkovic and Grunske, 2007. Nierstrasz et al., 2002). Components are autonomous units with independent life cycle that represent an specific functionality. A component consists of functionality, interface and possibly other non functional characteristics. The development of bigger systems with components as building blocks is called Component Based Development (CBD). To make this possible it is necessary to adapt the traditional software engineering techniques and methods, or even defined new ones, to attend to specific CBD requirements. In the context of Component Based Software Engineering (CBSE) the objective is to define a set of practices that promotes the CBD. Formal methods improve the development process of software and hardware systems by helping designers to achieve dependability at different levels of abstractions such as requirements, specification, modeling and design. This is mainly due to the fact that the application of formal methods helps discovering and removing errors by performing automatic analysis and verification (Clarke and Wing, 1996). Petri nets (Murata, 1989), and more specifically Hierarchical Coloured Petri Nets (HCPN) (Jensen, 1992. Jensen, 1997) are a very powerful tool that has been widely studied and applied for the specification and analysis of complex concurrent systems (Donatelli and Thiagarajan, 2006. Kleijn and Yakovlev, 2007. Jensen, 2005. Jensen, 2006). It has a graphical representation that helps the design of complex software systems. There are several advantages of using a formal method in systems design such as, automatic simulation, proof of properties and unambiguous documentation. In the context of software engineering, the reuse of artifacts in the development of new software systems increases the productivity. Also, the reuse of artifacts that are well known to be correct is an effective way to increase the dependability on the system under development. Reuse is not restricted to pieces of source code, but it can be also be applied to