29 research outputs found
(Co-)Inductive semantics for Constraint Handling Rules
In this paper, we address the problem of defining a fixpoint semantics for
Constraint Handling Rules (CHR) that captures the behavior of both
simplification and propagation rules in a sound and complete way with respect
to their declarative semantics. Firstly, we show that the logical reading of
states with respect to a set of simplification rules can be characterized by a
least fixpoint over the transition system generated by the abstract operational
semantics of CHR. Similarly, we demonstrate that the logical reading of states
with respect to a set of propagation rules can be characterized by a greatest
fixpoint. Then, in order to take advantage of both types of rules without
losing fixpoint characterization, we present an operational semantics with
persistent. We finally establish that this semantics can be characterized by
two nested fixpoints, and we show the resulting language is an elegant
framework to program using coinductive reasoning.Comment: 17 page
Un Système de Module Fermé pour la PLC
http://www710.univ-lyon1.fr/~csolnonCet article présente un système de modules pour la Programmation Logique par Contraintes. Ce système simple et relativement indépendant du langage précis d'utilisation (il a été conçu à l'origine pour GNU-Prolog) a la particularité d'être fermé. Par fermé nous entendons, le fait qu'il est capable de prévenir tout appel à des parties privées d'un module depuis l'extérieur de celui-ci. Bien qu'il puisse être vu comme une simple couche de sucre syntaxique, ce système offre une discipline de nommage des prédicats permettant de développer des bibliothèques et de faciliter la réutilisation du code. De plus, en ajoutant au langage une forme de fermeture inspirée de la programmation concurrente linéaire par contraintes, nous montrons comment on résout le problème bien connu de l'utilisation de la méta-programmation à travers le système de modules, en distinguant l'exécution d'un terme (prédicat call) de l'application d'une fermeture (ordre supérieur)
Closures are Needed for Closed Module Systems
In a classical paper of D.H.D. Warren, the higher-order extensions of Prolog were questioned as they do not really provide more expressive power than meta-programming predicates. Without disputing this argumentation in the context of a logic programming system without modules, we show that the situation is different in a closed module system. By closed we mean the property that the module system is able to prevent any call to the private predicates of a module from the other modules, in particular through meta-programming predicates. We show that this property necessitates to distinguish the execution of a term (meta-programming predicate call) from the execution of a closure (higher order). We propose a module system for Constraint Logic Programming with a notion of closures inspired from Linear Concurrent Constraint programming. This module system is quite simple and pretty independent of a precise language (it is currently implemented for GNU-Prolog). Although this system can be seen as a simple layer of syntactic sugar, it does provide a discipline for naming predicates and hiding code, making possible the development of libraries and facilitating the safe re-use of existing code. Furthermore we provide the module system with logical and operational semantics. This formal setting is used in the paper to compare our approach to the other module systems proposed for Prolog, which generally do not ensure full code protection
Work Analysis with Resource-Aware Session Types
While there exist several successful techniques for supporting programmers in
deriving static resource bounds for sequential code, analyzing the resource
usage of message-passing concurrent processes poses additional challenges. To
meet these challenges, this article presents an analysis for statically
deriving worst-case bounds on the total work performed by message-passing
processes. To decompose interacting processes into components that can be
analyzed in isolation, the analysis is based on novel resource-aware session
types, which describe protocols and resource contracts for inter-process
communication. A key innovation is that both messages and processes carry
potential to share and amortize cost while communicating. To symbolically
express resource usage in a setting without static data structures and
intrinsic sizes, resource contracts describe bounds that are functions of
interactions between processes. Resource-aware session types combine standard
binary session types and type-based amortized resource analysis in a linear
type system. This type system is formulated for a core session-type calculus of
the language SILL and proved sound with respect to a multiset-based operational
cost semantics that tracks the total number of messages that are exchanged in a
system. The effectiveness of the analysis is demonstrated by analyzing standard
examples from amortized analysis and the literature on session types and by a
comparative performance analysis of different concurrent programs implementing
the same interface.Comment: 25 pages, 2 pages of references, 11 pages of appendix, Accepted at
LICS 201
Observational equivalences for linear logic CC languages
Linear logic Concurrent Constraint programming (LCC) is an extension of
concurrent constraint programming (CC) where the constraint system is based on
Girard's linear logic instead of the classical logic. In this paper we address
the problem of program equivalence for this programming framework. For this
purpose, we present a structural operational semantics for LCC based on a label
transition system and investigate different notions of observational
equivalences inspired by the state of art of process algebras. Then, we
demonstrate that the asynchronous \pi-calculus can be viewed as simple
syntactical restrictions of LCC. Finally we show LCC observational equivalences
can be transposed straightforwardly to classical Concurrent Constraint
languages and Constraint Handling Rules, and investigate the resulting
equivalences.Comment: 17 page
A Transformational Approach to Parametric Accumulated-Cost Static Profiling
Traditional static resource analyses estimate the total resource usage of a program, without executing it. In this paper we present a novel resource analysis whose aim is instead the static profiling of accumulated cost, i.e., to discover, for selected parts of the program, an estimate or bound of the resource usage accumulated in each of those parts. Traditional resource analyses are parametric in the sense that the results can be functions on input data sizes. Our static profiling is also parametric, i.e., our accumulated cost estimates are also parameterized by input data sizes. Our proposal is based on the concept of cost centers and a program transformation that allows the static inference of functions that return bounds on these accumulated costs depending on input data sizes, for each cost center of interest. Such information is much more useful to the software developer than the traditional resource usage functions, as it allows identifying the parts of a program that should be optimized, because of their greater impact on the total cost of program executions. We also report on our implementation of the proposed technique using the CiaoPP program analysis framework, and provide some experimental results
Lightweight compilation of (C)LP to JavaScript
We present and evaluate a compiler from Prolog (and extensions) to JavaScript which makes it possible to use (constraint) logic programming to develop the client side of web applications while being compliant with current industry standards. Targeting JavaScript makes (C)LP programs executable in virtually every modern computing device with no additional software requirements from the point of view of the user. In turn, the use of a very high-level language facilitates the development of high-quality, complex software. The compiler is a back end of the Ciao system and supports most of its features, including its module system and its rich language extension mechanism based on packages. We present an overview of the compilation process and a detailed description of the run-time system, including the support for modular compilation into separate JavaScript code. We demonstrate the maturity of the compiler by testing it with complex code such as a CLP(FD) library written in Prolog with attributed variables. Finally, we validate our proposal by measuring the performance of some LP and CLP(FD) benchmarks running on top of major JavaScript engines
ENTRA:Whole-systems energy transparency
Promoting energy efficiency to a first class system design goal is an
important research challenge. Although more energy-efficient hardware can be
designed, it is software that controls the hardware; for a given system the
potential for energy savings is likely to be much greater at the higher levels
of abstraction in the system stack. Thus the greatest savings are expected from
energy-aware software development, which is the vision of the EU ENTRA project.
This article presents the concept of energy transparency as a foundation for
energy-aware software development. We show how energy modelling of hardware is
combined with static analysis to allow the programmer to understand the energy
consumption of a program without executing it, thus enabling exploration of the
design space taking energy into consideration. The paper concludes by
summarising the current and future challenges identified in the ENTRA project.Comment: Revised preprint submitted to MICPRO on 27 May 2016, 23 pages, 3
figure