Visualizador de programas Java concurrentes

El presente trabajo fin de grado, que, a partir de ahora, denominaré TFG, consiste en elaborar una monitorización de programas concurrentes en lenguaje Java, para que se visualicen los eventos ocurridos durante la ejecución de los dichos programas. Este trabajo surge en el marco de la asignatura “Concurrencia” de la Escuela Técnica Superior de Ingeniería Informática de la Universidad Politécnica de Madrid, impartida por D. Julio Mariño y D. Ángel Herranz. El objetivo principal de este proyecto es crear una herramienta para el aprendizaje de la asignatura de concurrencia, facilitando la comprensión de los conceptos teóricos, de modo que puedan corregir los posibles errores que haya en sus prácticas. en este proyecto se expone el desarrollo de una librería de visualización de programas concurrentes programados en Java usando un formalismo gráfico similar al empleado en la asignatura. Además esta librería da soporte a los mecanismos de sincronización usados en las prácticas de la asignatura: la librería Monitor (desarrollada por los profesores de la asignatura, D. Ángel Herranz y D. Julio Mariño) y la librería JCSP (Universidad de Kent). ---ABSTRACT---This Bachelor Thesis addresses the problem of monitoring a Java program in order to trace and visualize a certain set of events produced during the execution of concurrent Java programs. This work originates in the subject "Concurrency" of the Computer Science and Engineering degree of our University. The main goal of this work is to have a tool that helps students learning the subject, so they can better understand the core concepts and correct common mistakes in the course practical work. We have implemented a library for visualizing concurrent Java programsusing a graphical notation similar to the one used in class, which supports the design of concurrent programs whose synchronization mechanisms are either monitors(using the Monitor package) or CSP(as implemented in the JCSP library from Kent University).

Análisis de datos y modelado simbólico para aplicación de detección temprana de trastornos del lenguaje

Este Proyecto Fin de Grado trabaja en pos de la mejora y ampliación de los sistemas Pegaso y Gades, dos Sistemas Expertos enmarcados en el ámbito de la e-Salud. Estos sistemas, que ya estaban en funcionamiento antes del comienzo de este trabajo, apoyan la toma de decisiones en Atención Primaria. Esto es, permiten evaluar el nivel de adquisición del lenguaje en niños de 0 a 6 años a través de sus respectivas aplicaciones web. Además, permiten almacenar dichas evaluaciones y consultarlas posteriormente, junto con las decisiones del sistema asociadas a las mismas. Pegaso y Gades siguen una arquitectura de tres capas y están desarrollados usando fundamentalmente componentes Java y siguiendo. Como parte de este trabajo, en primer lugar se solucionan algunos problemas en el comportamiento de ambos sistemas, como su incompatibilidad con Java SE 7. A continuación, se desarrolla una aplicación que permite generar una ontología en lenguaje OWL desde código Java. Para ello, se estudia primero el concepto de ontología, el lenguaje OWL y las diferentes librerías Java existentes para generar ontologías OWL. Por otra parte, se mejoran algunas de las funcionalidades de los sistemas de partida y se desarrolla una nueva funcionalidad para la explotación de los datos almacenados en las bases de datos de ambos sistemas Esta nueva funcionalidad consiste en un módulo responsable de la generación de estadísticas a partir de los datos de las evaluaciones del lenguaje que hayan sido realizadas y, por tanto, almacenadas en las bases de datos. Estas estadísticas, que pueden ser consultadas por todos los usuarios de Pegaso y Gades, permiten establecer correlaciones entre los diversos conjuntos de datos de las evaluaciones del lenguaje. Por último, las estadísticas son mostradas por pantalla en forma de varios tipos de gráficas y tablas, de modo que los usuarios expertos puedan analizar la información contenida en ellas. ABSTRACT. This Bachelor's Thesis works towards improving and expanding the systems Pegaso and Gades, which are two Expert Systems that belong to the e-Health field. These systems, which were already operational before starting this work, support the decision-making process in Primary Care. That is, they allow to evaluate the language acquisition level in children from 0 to 6 years old. They also allow to store these evaluations and consult them afterwards, together with the decisions associated to each of them. Pegaso and Gades follow a three-tier architecture and are developed using mainly Java components. As part of this work, some of the behavioural problems of both systems are fixed, such as their incompatibility with Java SE 7. Next, an application that allows to generate an OWL ontology from Java code is developed. In order to do that, the concept of ontology, the OWL language and the different existing Java libraries to generate OWL ontologies are studied. On the other hand, some of the functionalities of the initial systems are improved and a new functionality to utilise the data stored in the databases of both systems is developed. This new functionality consists of a module responsible for the generation of statistics from the data of the language evaluations that have been performed and, thus, stored in the databases. These statistics, which can be consulted by all users of Pegaso and Gades, allow to establish correlations between the diverse set of data from the language evaluations. Finally, the statistics are presented to the user on the screen in the shape of various types of charts and tables, so that the expert users can analyse the information contained in them.

Advanced Topics in Resource Analysis: Certification, Incrementality, Concurrency and Array-Sensitivity

El Análisis de Consumo de Recursos o Análisis de Coste trata de aproximar el coste de ejecutar un programa como una función dependiente de sus datos de entrada. A pesar de que existen trabajos previos a esta tesis doctoral que desarrollan potentes marcos para el análisis de coste de programas orientados a objetos, algunos aspectos avanzados, como la eficiencia, la precisión y la fiabilidad de los resultados, todavía deben ser estudiados en profundidad. Esta tesis aborda estos aspectos desde cuatro perspectivas diferentes: (1) Las estructuras de datos compartidas en la memoria del programa son una pesadilla para el análisis estático de programas. Trabajos recientes proponen una serie de condiciones de localidad para poder mantener de forma consistente información sobre los atributos de los objetos almacenados en memoria compartida, reemplazando éstos por variables locales no almacenadas en la memoria compartida. En esta tesis presentamos dos extensiones a estos trabajos: la primera es considerar, no sólo los accesos a los atributos, sino también los accesos a los elementos almacenados en arrays; la segunda se centra en los casos en los que las condiciones de localidad no se cumplen de forma incondicional, para lo cual, proponemos una técnica para encontrar las precondiciones necesarias para garantizar la consistencia de la información acerca de los datos almacenados en memoria. (2) El objetivo del análisis incremental es, dado un programa, los resultados de su análisis y una serie de cambios sobre el programa, obtener los nuevos resultados del análisis de la forma más eficiente posible, evitando reanalizar aquellos fragmentos de código que no se hayan visto afectados por los cambios. Los analizadores actuales todavía leen y analizan el programa completo de forma no incremental. Esta tesis presenta un análisis de coste incremental, que, dado un cambio en el programa, reconstruye la información sobre el coste del programa de todos los métodos afectados por el cambio de forma incremental. Para esto, proponemos (i) un algoritmo multi-dominio y de punto fijo que puede ser utilizado en todos los análisis globales necesarios para inferir el coste, y (ii) una novedosa forma de almacenar las expresiones de coste que nos permite reconstruir de forma incremental únicamente las funciones de coste de aquellos componentes afectados por el cambio. (3) Las garantías de coste obtenidas de forma automática por herramientas de análisis estático no son consideradas totalmente fiables salvo que la implementación de la herramienta o los resultados obtenidos sean verificados formalmente. Llevar a cabo el análisis de estas herramientas es una tarea titánica, ya que se trata de herramientas de gran tamaño y complejidad. En esta tesis nos centramos en el desarrollo de un marco formal para la verificación de las garantías de coste obtenidas por los analizadores en lugar de analizar las herramientas. Hemos implementado esta idea mediante la herramienta COSTA, un analizador de coste para programas Java y KeY, una herramienta de verificación de programas Java. De esta forma, COSTA genera las garantías de coste, mientras que KeY prueba la validez formal de los resultados obtenidos, generando de esta forma garantías de coste verificadas. (4) Hoy en día la concurrencia y los programas distribuidos son clave en el desarrollo de software. Los objetos concurrentes son un modelo de concurrencia asentado para el desarrollo de sistemas concurrentes. En este modelo, los objetos son las unidades de concurrencia y se comunican entre ellos mediante llamadas asíncronas a sus métodos. La distribución de las tareas sugiere que el análisis de coste debe inferir el coste de los diferentes componentes distribuidos por separado. En esta tesis proponemos un análisis de coste sensible a objetos que, utilizando los resultados obtenidos mediante un análisis de apunta-a, mantiene el coste de los diferentes componentes de forma independiente. Abstract Resource Analysis (a.k.a. Cost Analysis) tries to approximate the cost of executing programs as functions on their input data sizes and without actually having to execute the programs. While a powerful resource analysis framework on object-oriented programs existed before this thesis, advanced aspects to improve the efficiency, the accuracy and the reliability of the results of the analysis still need to be further investigated. This thesis tackles this need from the following four different perspectives. (1) Shared mutable data structures are the bane of formal reasoning and static analysis. Analyses which keep track of heap-allocated data are referred to as heap-sensitive. Recent work proposes locality conditions for soundly tracking field accesses by means of ghost non-heap allocated variables. In this thesis we present two extensions to this approach: the first extension is to consider arrays accesses (in addition to object fields), while the second extension focuses on handling cases for which the locality conditions cannot be proven unconditionally by finding aliasing preconditions under which tracking such heap locations is feasible. (2) The aim of incremental analysis is, given a program, its analysis results and a series of changes to the program, to obtain the new analysis results as efficiently as possible and, ideally, without having to (re-)analyze fragments of code that are not affected by the changes. During software development, programs are permanently modified but most analyzers still read and analyze the entire program at once in a non-incremental way. This thesis presents an incremental resource usage analysis which, after a change in the program is made, is able to reconstruct the upper-bounds of all affected methods in an incremental way. To this purpose, we propose (i) a multi-domain incremental fixed-point algorithm which can be used by all global analyses required to infer the cost, and (ii) a novel form of cost summaries that allows us to incrementally reconstruct only those components of cost functions affected by the change. (3) Resource guarantees that are automatically inferred by static analysis tools are generally not considered completely trustworthy, unless the tool implementation or the results are formally verified. Performing full-blown verification of such tools is a daunting task, since they are large and complex. In this thesis we focus on the development of a formal framework for the verification of the resource guarantees obtained by the analyzers, instead of verifying the tools. We have implemented this idea using COSTA, a state-of-the-art cost analyzer for Java programs and KeY, a state-of-the-art verification tool for Java source code. COSTA is able to derive upper-bounds of Java programs while KeY proves the validity of these bounds and provides a certificate. The main contribution of our work is to show that the proposed tools cooperation can be used for automatically producing verified resource guarantees. (4) Distribution and concurrency are today mainstream. Concurrent objects form a well established model for distributed concurrent systems. In this model, objects are the concurrency units that communicate via asynchronous method calls. Distribution suggests that analysis must infer the cost of the diverse distributed components separately. In this thesis we propose a novel object-sensitive cost analysis which, by using the results gathered by a points-to analysis, can keep the cost of the diverse distributed components separate.

A model-driven approach to teaching concurrency

We present an undergraduate course on concurrent programming where formal models are used in different stages of the learning process. The main practical difference with other approaches lies in the fact that the ability to develop correct concurrent software relies on a systematic transformation of formal models of inter-process interaction (so called shared resources), rather than on the specific constructs of some programming language. Using a resource-centric rather than a language-centric approach has some benefits for both teachers and students. Besides the obvious advantage of being independent of the programming language, the models help in the early validation of concurrent software design, provide students and teachers with a lingua franca that greatly simplifies communication at the classroom and during supervision, and help in the automatic generation of tests for the practical assignments. This method has been in use, with slight variations, for some 15 years, surviving changes in the programming language and course length. In this article, we describe the components and structure of the current incarnation of the course?which uses Java as target language?and some tools used to support our method. We provide a detailed description of the different outcomes that the model-driven approach delivers (validation of the initial design, automatic generation of tests, and mechanical generation of code) from a teaching perspective. A critical discussion on the perceived advantages and risks of our approach follows, including some proposals on how these risks can be minimized. We include a statistical analysis to show that our method has a positive impact in the student ability to understand concurrency and to generate correct code.

Concurrent library abstraction without information hiding

The commonly accepted approach to specifying libraries of concurrent algorithms is a library abstraction. Its idea is to relate a library to another one that abstracts away from details of its implementation and is simpler to reason about. A library abstraction relation has to validate the Abstraction Theorem: while proving a property of the client of the concurrent library, the library can be soundly replaced with its abstract implementation. Typically a library abstraction relation, such as linearizability, assumes a complete information hiding between a library and its client, which disallows them to communicate by means of shared memory. However, such way of communication may be used in a program, and correctness of interactions on a shared memory depends on the implicit contract between the library and the client. In this work we approach library abstraction without any assumptions about information hiding. To be able to formulate the contract between components of the program, we augment machine states of the program with two abstract states, views, of the client and the library. It enables formalising the contract with the internal safety, which requires components to preserve each other's views whenever their command is executed. We define the library a a correspondence between possible uses of a concrete and an abstract library. For our library abstraction relation and traces of a program, components of which follow their contract, we prove an Abstraction Theorem. RESUMEN. La técnica más aceptada actualmente para la especificación de librerías de algoritmos concurrentes es la abstracción de librerías (library abstraction). La idea subyacente es relacionar la librería original con otra que abstrae los detalles de implementación y conóon que describa dicha abstracción de librerías debe validar el Teorema de Abstracción: durante la prueba de la validez de una propiedad del cliente de la librería concurrente, el reemplazo de esta última por su implementación abstracta es lógicamente correcto. Usualmente, una relación de abstracción de librerías como la linearizabilidad (linearizability), tiene como premisa el ocultamiento de información entre el cliente y la librería (information hiding), es decir, que no se les permite comunicarse mediante la memoria compartida. Sin embargo, dicha comunicación ocurre en la práctica y la correctitud de estas interacciones en una memoria compartida depende de un contrato implícito entre la librería y el cliente. En este trabajo, se propone un nueva definición del concepto de abtracción de librerías que no presupone un ocultamiento de información entre la librería y el cliente. Con el fin de establecer un contrato entre diferentes componentes de un programa, extendemos la máquina de estados subyacente con dos estados abstractos que representan las vistas del cliente y la librería. Esto permite la formalización de la propiedad de seguridad interna (internal safety), que requiere que cada componente preserva la vista del otro durante la ejecuci on de un comando. Consecuentemente, se define la relación de abstracción de librerías mediante una correspondencia entre los usos posibles de una librería abstracta y una concreta. Finalmente, se prueba el Teorema de Abstracción para la relación de abstracción de librerías propuesta, para cualquier traza de un programa y cualquier componente que satisface los contratos apropiados.