A Model-Based Approach for Reconciliation of Polychronous Execution Traces

International audienceEmbedded systems are very difficult to design and debug because of the limited access to the device itself. Therefore, debugging usually requires to instrument the code so as to produce execution traces that are then monitored from a base station. Such an intrusive method has a direct impact on performances. In case of multiple interacting embedded targets the problem is even more severe and is not limited to computations but also spreads to communications. To reduce the communication overhead, we propose an approach in which unsynchronized traces from several targets are reconciled a posteriori. Since each target has its own time base without a built-in clock synchronization protocol, our approach requires a multi-clock reconciliation specification. This paper describes our model-based proposal developed during the ANR project RT-Simex. The different steps of the reconciliation are illustrated on a simple case-study used in the project, a terrestrial robot controlled in position

An Animation Framework for Improving the Comprehension of TinyOS Programs

To meet the increasing demand for monitoring of the physical world, there has been an increase in the development of wireless sensor network applications. The TinyOS platform has emerged as a de facto standard for developing these applications. The platform offers a number of advantages, with its support for concurrency, power-efficient operation, and resource-constrained hardware chief among them. However, the benefits come at a price. Even without the TinyOS platform, the inherent parallel and distributed nature of these applications makes it difficult for developers to reason about program behavior. Further, the TinyOS programming model adopts asynchronous, split-phase execution semantics. Developers must explicitly manage program control state across event-handlers, components, and devices. This makes the design, debugging, and comprehension of these programs even more difficult. In this work, we describe an animation framework for TinyOS programs, designed to enhance the comprehension of their runtime behavior. The framework enables application developers to specify, in the form of an XML configuration file, the runtime elements to be captured within a given system and the manner in which those elements should be displayed. The resulting visualization presents an animated play-back sequence of the events that occurred during execution. The framework also provides a visual representation that connects causally-related events in a distributed network. We describe the design and implementation of the animation framework and present an analysis of the runtime overhead it introduces

Formally Tracing Executions From an Analysis Tool Back to a Domain Specific Modeling Language's Operational Semantics

The increasing complexity of software development requires rigorously defined domain specific modelling languages (DSML). Model-driven engineering (MDE) allows users to define their language's syntax in terms of metamodels. Several approaches for defining operational semantics of DSML have also been proposed. These approaches allow, in principle, for model execution and for formal analyses of the DSML. However, most of the time, the executions/analyses are performed via transformations to other languages: code generation, resp. translation to the input language of a model checker. The consequence is that the results (e.g., a program crash log, or a counterexample returned by a model checker) may not be straightforward to interpret by the users of a DSML. In this research report, we propose a formal and operational framework for tracing such results back to the original DSML's syntax and operational semantics.Le besoin en définitions rigoureuses de langages de modélisation métiers (LMM) croît avec la complexité du développement logiciel. L'ingénierie dirigée par les modèles (IDM), permet à des utilisateurs de définir la syntaxe de nouveaux langages à l'aide de metamodèles. Quelques approches proposent également des façons de définir la sémantique opérationnelle de ces langages. Ces approches permettent, en principe, l'exécution des programmes (modèles) et leur analyse formelle. Cependant, la plupart du temps, les analyses sont réalisées à l'aide de transformations de ces modèles vers d'autres langages, pour être exécutés (langages généralistes, type C par exemple) ou vérifiés (langages d'entrées de model checkers, de simulateurs, ...). En conséquence, ces résultats (un log de crash de programme, une exécution contre exemple provenant de la vérification d'une propriété par un model-checker, par exemple) peuvent ne pas être directement compréhensibles par les utilisateurs d'un LMM. Dans ce rapport, nous proposons une méthode formelle et opérationnelle pour exprimer ces exécutions en terme de syntaxe et sémantique du LMM initial

Regression test selection for distributed Java RMI programs by means of formal concept analysis

Software maintenance is the process of modifying an existing system to ensure that it meets current and future requirements. As a result, performing regression testing becomes an essential but time consuming aspect of any maintenance activity. Regression testing is initiated after a programmer has made changes to a program that may have inadvertently introduced errors. It is a quality control approach to ensure that the newly modified code still complies with its specified requirements and that unmodified code has not been affected by the maintenance activity. In the literature various types of test selection techniques have been proposed to reduce the effort associated with re-executing the required test cases. However, the majority of these approach has been focusing only on sequential programs, and provide no or only very limited support for distributed programs or database-driven applications. The thesis presents a lightweight methodology, which applies Formal Concept Analysis to support a regression test selection analysis, in combination with execution trace collection and external data sharing analysis, for distributed Java RMI programs. Two Eclipse plug-ins were developed to automate the regression test selection process and to evaluate our methodology

Understanding Distributed Systems via Execution Trace Data

One of the most challenging problems facing today's software engineer is to understand and modify distributed systems. One reason is that in actual use systems frequently behave differently than the designer intended. We describe a three-step method to allow a developer to understand the run-time behavior of a distributed system. First, remote procedure calls are traced using CORBA interceptors. Next, the trace data is parsed to construct RPC call-return sequences, and summary statistics are generated. Finally, a visualization tool is used to study the statistics and look for anomalous behavior. We are testing this method on a large distributed system (more than 600,000 lines of code) during operation at a customer 's site. Despite the fact that the system has been in operation for over three years, we are finding system configuration and efficiency problems using the method. Keywords: CORBA, distributed systems, execution vis ualization, Tracing 1. Introduction Understanding the ex..