The Experts below are selected from a list of 552 Experts worldwide ranked by ideXlab platform
Costiou Steven - One of the best experts on this subject based on the ideXlab platform.
-
Unanticipated behavior adaptation : application to the Debugging of running programs
2018Co-Authors: Costiou StevenAbstract:Certains programmes doivent fonctionner en continu et ne peuvent pas être interrompus en cas de dysfonctionnement. C'est par exemple le cas de drones en mission, de satellites et de certains objets connectés. Pour de telles applications, le défi est d’identifier les problèmes et de les corriger pendant l'exécution du programme. De plus, dans le contexte des systèmes à objets, il peut être nécessaire d’observer et d’instrumenter individuellement le comportement de certains objets particuliers. Dans cette thèse, nous proposons une solution d’adaptation dynamique de comportement permettant de déverminer individuellement les objets d'un programme en cours d'exécution. Cette solution est présentée sous la forme d’un patron applicable aux langages objets à typage dynamique. Ce patron permet d'implanter de façon minimale et générique des capacités additionnelles d’adaptation dynamique à granularité objet. Une mise en oeuvre de ce patron pour un langage de programmation particulier permet d'instrumenter dynamiquement un programme pour collecter des objets spécifiques et d'adapter leur comportement pendant l’exécution. Nous expérimentons notre patron par des mises en oeuvre en Pharo et en Python. Des dévermineurs dédiés à la mise au point de programmes en cours d’exécution sont mis en oeuvre pour ces deux langages objet. Ces outils sont évalués pour des cas de déverminage concrets : pour une simulation de drones, pour des applications connectées déployées sur des systèmes cyber-physiques distants, pour un serveur de discussion en ligne ainsi que sur un défaut en production d’un logiciel de génération de documents.Some programs must run continuously and cannot be interrupted in the event of a malfunction.This is, for example, the case of drones, satellites and some internet-of-things applications. For such applications, the challenge is to identify and fix problems while the program is still running. Moreover, in the context of object-oriented Systems, it may be necessary to observe and instrument the behavior of very specifie objects.In this thesis, we propose a method to adapt object behavior in a running program. This solution is presented as a pattern applicable to dynamically typed object-oriented languages. This pattern makes it possible to implement, in a minimal and generic way, additional Debugging capabilities at the level of objects. An implementation of this pattern for a particular programming language makes it possible to dynamically instrument a program, by collecting specifie objects and adapting their behavior during run-time. We experiment this pattern in Pharo and Python implementations with dedicated debuggers for each language.These tools are evaluated on typical Debugging case studies: a simulation of drones, connected applications deployed on remote cyber-physical Systems, an online discussion server and a Debugging Session to fix a defect in a production software
-
Adaptation non-anticipée de comportement : application au déverminage de programmes en cours d'exécution
HAL CCSD, 2018Co-Authors: Costiou StevenAbstract:Some programs must run continuously and cannot be interrupted in the event of a malfunction.This is, for example, the case of drones, satellites and some internet-of-things applications. For such applications, the challenge is to identify and fix problems while the program is still running. Moreover, in the context of object-oriented Systems, it may be necessary to observe and instrument the behavior of very specifie objects.In this thesis, we propose a method to adapt object behavior in a running program. This solution is presented as a pattern applicable to dynamically typed object-oriented languages. This pattern makes it possible to implement, in a minimal and generic way, additional Debugging capabilities at the level of objects. An implementation of this pattern for a particular programming language makes it possible to dynamically instrument a program, by collecting specifie objects and adapting their behavior during run-time. We experiment this pattern in Pharo and Python implementations with dedicated debuggers for each language.These tools are evaluated on typical Debugging case studies: a simulation of drones, connected applications deployed on remote cyber-physical Systems, an online discussion server and a Debugging Session to fix a defect in a production software.Certains programmes doivent fonctionner en continu et ne peuvent pas être interrompus en cas de dysfonctionnement. C'est par exemple le cas de drones en mission, de satellites et de certains objets connectés. Pour de telles applications, le défi est d’identifier les problèmes et de les corriger pendant l'exécution du programme. De plus, dans le contexte des systèmes à objets, il peut être nécessaire d’observer et d’instrumenter individuellement le comportement de certains objets particuliers. Dans cette thèse, nous proposons une solution d’adaptation dynamique de comportement permettant de déverminer individuellement les objets d'un programme en cours d'exécution. Cette solution est présentée sous la forme d’un patron applicable aux langages objets à typage dynamique. Ce patron permet d'implanter de façon minimale et générique des capacités additionnelles d’adaptation dynamique à granularité objet. Une mise en oeuvre de ce patron pour un langage de programmation particulier permet d'instrumenter dynamiquement un programme pour collecter des objets spécifiques et d'adapter leur comportement pendant l’exécution. Nous expérimentons notre patron par des mises en oeuvre en Pharo et en Python. Des dévermineurs dédiés à la mise au point de programmes en cours d’exécution sont mis en oeuvre pour ces deux langages objet. Ces outils sont évalués pour des cas de déverminage concrets : pour une simulation de drones, pour des applications connectées déployées sur des systèmes cyber-physiques distants, pour un serveur de discussion en ligne ainsi que sur un défaut en production d’un logiciel de génération de documents
A Beers - One of the best experts on this subject based on the ideXlab platform.
-
monitoring data structure evolution in distributed message passing programs
Hawaii International Conference on System Sciences, 1996Co-Authors: S R Sarukkai, A BeersAbstract:Monitoring the evolution of data structures in parallel and distributed programs, is critical for Debugging its semantics and performance. However, the current state-of-art in tracking and presenting data-structure information on parallel and distributed environments is cumbersome and does not scale. We present a methodology and tool that automatically tracks memory bindings (not the actual contents) of dynamic data-structures of message-passing C programs, and inter-processor data-structure movement, using PVM on distributed environments. With the help of a number of examples we show that in addition to determining the impact of memory allocation overheads on program performance, graphical views can help in Debugging many memory access errors. Traditional debuggers in distributed environments rely on existing sequential debuggers on each machine and simply provide an interface for querying and controlling each processor's Debugging Session. However, to quickly locate the processor and to explain reasons for the error, we resort to run-time checking and trace based visualizations of memory access behavior across all processors. In an effort to reduce trace file size, only updates of pointer values and memory management functions are captured.
Jakse Raphaël - One of the best experts on this subject based on the ideXlab platform.
-
Vérification interactive de propriétés à l'exécution
HAL CCSD, 2019Co-Authors: Jakse RaphaëlAbstract:Computers are ubiquitous. We trust them for a huge and increasing number of tasks, some critical. Consequences of software defects are various, from little annoyances to the loss of multiple lives. Hence, ensuring software reliability is instrumental.Fixing bugs is a very time-consuming activity of the software development cycle. In this thesis, we present interactive runtime verification (i-RV), which combines runtime verification and interactive Debugging. Runtime verification is a formal method to study the behavior of a system at runtime. It consists in matching runtime traces of a system at runtime against behavioral properties. These properties are part of the system specification. Interactive Debugging consists in studying a system at runtime in order to understand its bugs and fix them, inspecting its internal state interactively. Interactive runtime verification aims to make interactive Debugging less tedious and more systematic by leveraging the rigorous and automated aspects of runtime verification. We aim to ease the Debugging part of the software development cycle. We define an efficient and convenient way to check behavioral properties automatically on a program using an interactive debugger. We gather bug detection and bug understanding in an integrated workflow, by guiding interactive Debugging using runtime verification.We provide a formal model for interactively runtime verified programs. We model the execution of a program under a debugger composed with a monitor (for verdict emission) and a scenario (for steering the Debugging Session). We provide guarantees on the soundness of the verdicts issued by the monitor by exhibiting a weak simulation (relation) between the initial program and the interactively runtime verified program. Moreover, we provide an algorithmic view of this model suitable for producing implementations. We then introduce a distributed and adaptive framework for interactive runtime verification. It allows checking several requirements simultaneously and Debugging a distributed system composed of communicating processes. The monitors, the scenario and the debugged programs themselves run distributed using an orchestrating protocol which we verified using the SPIN model checker. Our distributed framework is designed to adapt to existing components.We present Verde, an implementation of interactive runtime verification. A first version is based on the GNU Debugger (GDB) to interactively runtime verify C and C++ programs. A second version, Dist-Verde, is an implementation of our distributed framework compatible with C and C++ programs through GDB and Java programs through JDB, the Java Debugger.We report on experiments using Verde assessing the usefulness of interactive runtime verification and the performance of our implementation. Our results show that interactive runtime verification is applicable in a variety of cases and helps to study bugs.Les ordinateurs sont partout. Nous leur faisons confiance pour un grand, et grandissant, nombre de tâches, parmi lesquelles certaines sont critiques. Les conséquences des bogues logiciels sont diverses, de l'agacement léger à la mort de plusieurs personnes. Ainsi, il est important de s'assurer que les logiciels sont fiables.Corriger les bogues est une activité très chronophage du processus de développement logiciel. Dans cette thèse, nous présentons la vérification interactive à l'exécution, qui combine la vérification à l'exécution et le débogage interactif. La vérification à l'exécution est une méthode formelle pour étudier le comportement d'un système à l'exécution. Elle consiste à faire correspondre des traces d'exécutions d'un système avec des propriétés comportementales. Ces propriétés font partie des spécifications du système. Le débogage interactif consiste à étudier un système durant son exécution pour comprendre ses bogues et les corriger en inspectant interactivement son état interne. La vérification interactive à l'exécution a pour objectif de rendre le débogage interactif moins fastidieux et plus systématique en s'appuyant sur les aspects automatiques et rigoureux de la vérification à l'exécution. Nous avons pour but de faciliter la partie débogage du processus de développement logiciel. Nous définissons une manière efficace et pratique de vérifier des propriétés comportementales automatiquement sur un programme en utilisant un débogueur interactif. Nous rassemblons la détection et la compréhension de bogues dans une méthodologie intégrée, en guidant le débogage interactif avec la vérification à l'exécution.Nous fournissons un modèle formel pour les programmes vérifiés interactivement à l'exécution. Nous modélisons l'exécution d'un programme en train d'être débogué, composé avec un moniteur (pour l'émission de verdicts) et un scénario (pour conduire la Session de débogage). Nous fournissons des garanties sur la validité des verdicts produits par le moniteur en nous appuyant sur une relation de simulation faible entre le programme initial et le programme vérifié interactivement. De plus, nous fournissons une vue algorithmique du modèle adaptée à l'écriture d'implémentations. Nous introduisons ensuite un cadre et une architecture distribuée pour la vérification interactive à l'exécution. Cela permet de vérifier plusieurs propriétés simultanément et de déboguer un système distribué, composé de multiples processus communicants. Les moniteurs, le scénario et les programmes débogués eux-mêmes s'exécutent de façon distribuée en utilisant un protocole que nous avons vérifié avec le vérificateur de modèles SPIN. Notre architecture distribuée est conçue pour s'adapter à des composants existants.Nous présentons Verde, une implémentation de la vérification interactive à l'exécution. Une première version est basée sur le débogueur GNU (GDB) pour vérifier interactivement des programmes C et C++. Une deuxième version, Dist-Verde, est une implémentation de notre architecture distribuée compatible avec les programmes C et C++ à travers GDB et les programmes Java à travers JDB, le débogueur Java.Nous présentons des expérimentations en utilisant Verde, évaluant l'utilité de l'approche et les performances de notre implémentation. Nos résultats montrent que la vérification interactive à l'exécution est applicable dans une variété de cas et aide à étudier les bogues
S R Sarukkai - One of the best experts on this subject based on the ideXlab platform.
-
monitoring data structure evolution in distributed message passing programs
Hawaii International Conference on System Sciences, 1996Co-Authors: S R Sarukkai, A BeersAbstract:Monitoring the evolution of data structures in parallel and distributed programs, is critical for Debugging its semantics and performance. However, the current state-of-art in tracking and presenting data-structure information on parallel and distributed environments is cumbersome and does not scale. We present a methodology and tool that automatically tracks memory bindings (not the actual contents) of dynamic data-structures of message-passing C programs, and inter-processor data-structure movement, using PVM on distributed environments. With the help of a number of examples we show that in addition to determining the impact of memory allocation overheads on program performance, graphical views can help in Debugging many memory access errors. Traditional debuggers in distributed environments rely on existing sequential debuggers on each machine and simply provide an interface for querying and controlling each processor's Debugging Session. However, to quickly locate the processor and to explain reasons for the error, we resort to run-time checking and trace based visualizations of memory access behavior across all processors. In an effort to reduce trace file size, only updates of pointer values and memory management functions are captured.
Anderson, Thomas E. - One of the best experts on this subject based on the ideXlab platform.
-
A Graphical Interactive Debugger for Distributed Systems
2018Co-Authors: Woos Doug, Tatlock Zachary, Ernst, Michael D., Anderson, Thomas E.Abstract:Designing and Debugging distributed systems is notoriously difficult. The correctness of a distributed system is largely determined by its handling of failure scenarios. The sequence of events leading to a bug can be long and complex, and it is likely to include message reorderings and failures. On single-node systems, interactive debuggers enable stepping through an execution of the program, but they lack the ability to easily simulate failure scenarios and control the order in which messages are delivered. Oddity is a graphical, interactive debugger for distributed systems. It brings the power of traditional step-through Debugging---fine-grained control and observation of a program as it executes---to distributed systems. It also enables exploratory testing, in which an engineer examines and perturbs the behavior of a system in order to better understand it, perhaps without a specific bug in mind. A programmer can directly control message and failure interleaving. Oddity supports time travel, allowing a developer to explore multiple branching executions of a system within a single Debugging Session. Above all, Oddity encourages distributed systems thinking: rather than assuming the normal case and attaching failure handling as an afterthought, distributed systems should be developed around the certainty of message loss and node failure. Graduate and undergraduate students used Oddity in two distributed systems classes. Usage tracking and qualitative surveys showed that students found Oddity useful for both Debugging and exploratory testing
