Some methodological issues in the design of CIAO, a generic, parallel concurrent constraint system

We informally discuss several issues related to the parallel execution of logic programming systems and concurrent logic programming systems, and their generalization to constraint programming. We propose a new view of these systems, based on a particular definition of parallelism. We argüe that, under this view, a large number of the actual systems and models can be explained through the application, at different levéis of granularity, of only a few basic principies: determinism, non-failure, independence (also referred to as stability), granularity, etc. Also, and based on the convergence of concepts that this view brings, we sketch a model for the implementation of several parallel constraint logic programming source languages and models based on a common, generic abstract machine and an intermedíate kernel language.

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.

Evaluación para el aprendizaje en la asignatura sistemas operativos en modalidad online: un estudio cualitativo basado en la taxonomía de Bloom

La asignatura Sistemas Operativos presenta dificultades para su aprendizaje, pero poco se conoce acerca de las mismas, ya que no han sido determinadas ni estudiadas por la literatura. Asimismo, los trabajos existentes sobre la enseñanza y aprendizaje de Sistemas Operativos se limitan a proponer distintos enfoques para impartir la asignatura y en general no evalúan el aprendizaje de los estudiantes para comprobar la eficacia del método propuesto ni usan metodologías de investigación rigurosas. Por otra parte, la impartición de la asignatura Sistemas Operativos en modalidad online ha sido escasamente estudiada y podría tener dificultades adicionales a las de la modalidad presencial, ya que el contexto online impone una serie de restricciones tanto para el profesor como para el estudiante. En la presente tesis se ha llevado a cabo una evaluación formativa en la asignatura Sistemas Operativos, perteneciente al Grado de Ingeniería Informática de una universidad online. El objetivo inicial de la evaluación era descubrir las dificultades de los estudiantes para la comprensión de los conceptos de la asignatura. Posteriormente y, dada la buena aceptación de la evaluación por parte de los estudiantes, se ampliaron los objetivos del trabajo para explorar los efectos de la evaluación realizada sobre el aprendizaje. La evaluación formativa diseñada está basada en la taxonomía revisada de Bloom y sus principales objetivos son: (a) promover el aprendizaje significativo y (b) hacer a los estudiantes conscientes de su proceso de aprendizaje. La metodología de investigación utilizada es el estudio de caso cualitativo y la muestra está constituida por 9 estudiantes del total de 13 matriculados en la asignatura. Los datos cualitativos analizados proceden de las pruebas de evaluación formativa llevadas a cabo por los estudiantes durante la impartición de la asignatura. Los conceptos de sistemas operativos que han resultado más difíciles de comprender en el curso online estudiado han sido las interrupciones y los semáforos. Además, alrededor de estos conceptos se han identificado las dificultades específicas y sus posibles causas. Las dificultades descubiertas acerca de los semáforos corroboran las investigaciones existentes en el área de programación concurrente. El resto de las dificultades identificadas no habían sido determinadas por la literatura existente. En cuanto a los efectos de la evaluación formativa sobre el aprendizaje, la evidencia empírica muestra que ésta ha provocado en los estudiantes una reflexión profunda sobre los conceptos de la asignatura y sobre su propio proceso de aprendizaje. El estudio de caso presentado puede ayudar a los profesores del área de ingeniería a crear evaluaciones formativas en cursos online. La tesis, por tanto, realiza aportaciones relevantes en las áreas de enseñanza y aprendizaje de sistemas operativos, evaluación formativa, metodologías cualitativas y educación online. ABSTRACT Operating Systems is a difficult subject to learn; however little is known about said difficulties, as they have not been studied nor determined by the relevant literature. Existing studies on teaching and learning the subject of operating systems are limited to presenting different approaches for teaching the subject and generally do not evaluate students’ learning to verify the effectiveness of the proposed methods, nor do they use rigorous research methodologies. On the other hand, there are very few studies on teaching operating systems online, which may inherently present more difficulties than the in-person format, since an online context imposes a series of restrictions on both professors and students, such as not having face-to-face interaction for communications. This thesis studies a formative assessment of the subject of operating systems, as part of the Degree in Information Technology Engineering for an online university. The initial objective of this assessment was to determine the students’ difficulties in conceptual comprehension for this subject. Once students had accepted the assessment, the study’s objectives were expanded to include an investigation of the effects of the assessment on learning. The designed formative assessment was based on Revised Bloom’s Taxonomy with the following main objectives: (a) to promote meaningful learning and (b) (b) to make students aware of their learning process. The research methodology involves a qualitative case study with a sample consisting of 9 of the total 13 students registered for this course. The qualitative data analyzed comes from the formative assessment tests taken by these students during the course. The most difficult operating systems concepts for students in the online course were interrupts and semaphores. Additionally, the specific difficulties and their possible causes have been identified. The students’ comprehension difficulties with semaphores corroborate the existing research in the area of concurrent programming. The other identified difficulties were not discussed in the existing literature. Regarding the effects of the formative assessment on learning, the empirical evidence shows that it causes students to reflect carefully on the subject’s concepts as well as their own learning process. The presented case study can help professors in the area of engineering to create formative assessments for online courses. This thesis, therefore, makes relevant contributions to the areas of teaching and learning operating systems, formative assessment, qualitative methodologies, and online education.

Using attributed variables in the implementation of concurrent and parallel logic programming systems

Incorporating the possibility of attaching attributes to variables in a logic programming system has been shown to allow the addition of general constraint solving capabilities to it. This approach is very attractive in that by adding a few primitives any logic programming system can be turned into a generic constraint logic programming system in which constraint solving can be user deñned, and at source level - an extreme example of the "glass box" approach. In this paper we propose a different and novel use for the concept of attributed variables: developing a generic parallel/concurrent (constraint) logic programming system, using the same "glass box" flavor. We argüe that a system which implements attributed variables and a few additional primitives can be easily customized at source level to implement many of the languages and execution models of parallelism and concurrency currently proposed, in both shared memory and distributed systems. We illustrate this through examples and report on an implementation of our ideas.

Towards a concurrent semantics-based analysis of CC and CLP. principles and practice of constraint programming

Abstract is not available.

On the uses of attributed variables in parallel and concurrent logic programming systems

Incorporating the possibility of attaching attributes to variables in a logic programming system has been shown to allow the addition of general constraint solving capabilities to it. This approach is very attractive in that by adding a few primitives any logic programming system can be turned into a generic constraint logic programming system in which constraint solving can be user defined, and at source level - an extreme example of the "glass box" approach. In this paper we propose a different and novel use for the concept of attributed variables: developing a generic parallel/concurrent (constraint) logic programming system, using the same "glass box" flavor. We argüe that a system which implements attributed variables and a few additional primitives can be easily customized at source level to implement many of the languages and execution models of parallelism and concurrency currently proposed, in both shared memory and distributed systems. We illustrate this through examples.

Análisis de sistemas eléctricos en microsatélites. Desarrollo de módulos para una Concurrent Design Facility (CFD)para el desarrollo y análisis de misiones espaciales = Analysis of microsatellites power subsystems (battery testing). Development and programming of a new Propulsion Module for a space mission Concurrent Design Facility (CDF)

El objetivo de este proyecto es recoger y explicar el conjunto de tareas realizadas durante el proceso de colaboración llevado a cabo en el Instituto de Microgravedad “Ignacio Da Riva” durante el curso académico 2014/2015, las cuales han conformado las prácticas externas cursadas en la titulación de Grado en Ingeniería Aeroespacial, y el Trabajo de Fin de Grado de la misma titulación. En este documento se pretende,además, poner de manifiesto la rigurosidad con la que se trabaja en el ámbito espacial y la importancia de los protocolos y procedimientos para asegurar un resultado adecuado en los trabajos realizados. Una parte importante del proyecto detalla los procesos de monitorización y mantenimiento de la batería del satélite universitario UPMSat-2 cuyo lanzamiento está previsto para el año próximo y el cual será el segundo satélite del mundo en incorporar una batería de Ión-Litio.

Análisis de sistemas eléctricos en microsatélites. Desarrollo de módulos para una Concurrent Design Facility (CDF) para desarrollo y análisis de misiones espaciales = Analysis of microsatellites power subsystems (battery testing). Development and programming of a new Orbit Design Module for a space mission Concurrent Design Facility (CDF)

El presente proyecto se ha realizado durante las prácticas curriculares que han tenido lugar en el Instituto Universitario de Microgravedad “Ignacio Da Riva” (IDR/UPM). A lo largo de estas prácticas se han llevado a cabo trabajos en diversos campos, todos relacionados con el UPMSat-2, desde el subsistema de potencia (placas solares y baterías) hasta el desarrollo de módulos para la Sala de Diseño Concurrente (Concurrent Design Facility, CDF). En la realización de las mismas se ha trabajado en equipo, junto con otros dos alumnos. El objetivo del proyecto es recopilar las tareas realizadas, proporcionando el desarrollo teórico necesario para llevar a cabo todas ellas. Al ser un trabajo con varias partes claramente diferenciadas, se ha optado por comenzar con unas páginas dedicadas a las misiones espaciales. A continuación el trabajo se adentra en el subsistema de potencia de un satélite, particularizando para el UPMSat-2. Finalmente, se proporciona la teoría necesaria para el desarrollo del módulo de misión de la CDF del IDR/UPM, software que se ha desarrollado y tiene reservado un espacio al final, en el cual se describe el programa y se realizan comparaciones de los resultados que proporciona frente a casos reales.

Análisis en sistemas eléctricos en microsatélites. Desarrollo de módulos para una Concurrent Design Facility (CDF) para desarrollo y análisis de misiones espaciales = Analysis of microsatellites power subsystems (battery testing). Development and programming of a new Orbit Design Module for a space mission Concurrent Design Facility (CDF)

El objetivo de este trabajo de fin de grado es la exposición de los resultados y conclusiones, fruto de las tareas desarrolladas durante las practicas curriculares en el Instituto Universitario de Microgravedad “Ignacio Da Riva” (IDR/UPM) el presente curso académico. La estructura del trabajo se compone de dos bloques diferenciados entre sí: el seguimiento de una batería y el desarrollo de un módulo para una CDF.

From eventual to atomic and locally atomic CC programs: A concurrent semantics

We present a concurrent semantics (i.e. a semantics where concurrency is explicitely represented) for CC programs with atomic tells. This allows to derive concurrency, dependency, and nondeterminism information for such languages. The ability to treat failure information puts CLP programs also in the range of applicability of our semantics: although such programs are not concurrent, the concurrency information derived in the semantics may be interpreted as possible parallelism, thus allowing to safely parallelize those computation steps which appear to be concurrent in the net. Dually, the dependency information may also be interpreted as necessary sequentialization, thus possibly exploiting it to schedule CC programs. The fact that the semantical structure contains dependency information suggests a new tell operation, which checks for consistency only the constraints it depends on, achieving a reasonable trade-off between efficiency and atomicity.

Some methodological issues in the design of CIAO - A generic, parallel concurrent constraint system

We informally discuss several issues related to the parallel execution of logic programming systems and concurrent logic programming systems, and their generalization to constraint programming. We propose a new view of these systems, based on a particular definition of parallelism. We argüe that, under this view, a large number of the actual systems and models can be explained through the application, at different levéis of granularity, of only a few basic principies: determinism, non-failure, independence (also referred to as stability), granularity, etc. Also, and based on the convergence of concepts that this view brings, we sketch a model for the implementation of several parallel constraint logic programming source languages and models based on a common, generic abstract machine and an intermedíate kernel language.

Parallelism and implementation of logic and constraint logic programming

CIAO is an advanced programming environment supporting Logic and Constraint programming. It offers a simple concurrent kernel on top of which declarative and non-declarative extensions are added via librarles. Librarles are available for supporting the ISOProlog standard, several constraint domains, functional and higher order programming, concurrent and distributed programming, internet programming, and others. The source language allows declaring properties of predicates via assertions, including types and modes. Such properties are checked at compile-time or at run-time. The compiler and system architecture are designed to natively support modular global analysis, with the two objectives of proving properties in assertions and performing program optimizations, including transparently exploiting parallelism in programs. The purpose of this paper is to report on recent progress made in the context of the CIAO system, with special emphasis on the capabilities of the compiler, the techniques used for supporting such capabilities, and the results in the áreas of program analysis and transformation already obtained with the system.

Implementing distributed concurrent constraint execution in the CIAO system

This paper describes the current prototype of the distributed CIAO system. It introduces the concepts of "teams" and "active modules" (or active objects), which conveniently encapsulate different types of functionalities desirable from a distributed system, from parallelism for achieving speedup to client-server applications. The user primitives available are presented and their implementation described. This implementation uses attributed variables and, as an example of a communication abstraction, a blackboard that follows the Linda model. Finally, the CIAO WWW interface is also briefly described. The unctionalities of the system are illustrated through examples, using the implemented primitives.

Automatic compile-time parallelization of CLP programs by analysis and transformation to a concurrent constraint language.

The concept of independence has been recently generalized to the constraint logic programming (CLP) paradigm. Also, several abstract domains specifically designed for CLP languages, and whose information can be used to detect the generalized independence conditions, have been recently defined. As a result we are now in a position where automatic parallelization of CLP programs is feasible. In this paper we study the task of automatically parallelizing CLP programs based on such analyses, by transforming them to explicitly concurrent programs in our parallel CC platform (CIAO) as well as to AKL. We describe the analysis and transformation process, and study its efficiency, accuracy, and effectiveness in program parallelization. The information gathered by the analyzers is evaluated not only in terms of its accuracy, i.e. its ability to determine the actual dependencies among the program variables, but also of its effectiveness, measured in terms of code reduction in the resulting parallelized programs. Given that only a few abstract domains have been already defined for CLP, and that none of them were specifically designed for dependency detection, the aim of the evaluation is not only to asses the effectiveness of the available domains, but also to study what additional information it would be desirable to infer, and what domains would be appropriate for further improving the parallelization process.

Lock-free Parallel Dynamic Programming

We show a method for parallelizing top down dynamic programs in a straightforward way by a careful choice of a lock-free shared hash table implementation and randomization of the order in which the dynamic program computes its subproblems. This generic approach is applied to dynamic programs for knapsack, shortest paths, and RNA structure alignment, as well as to a state-of-the-art solution for minimizing the máximum number of open stacks. Experimental results are provided on three different modern multicore architectures which show that this parallelization is effective and reasonably scalable. In particular, we obtain over 10 times speedup for 32 threads on the open stacks problem.