Results 1  10
of
14
From Datalog rules to efficient programs with time and space guarantees
 In PPDP ’03: Proceedings of the 5th ACM SIGPLAN International Conference on Principles and Practice of Declarative Programming
, 2003
"... This paper describes a method for transforming any given set of Datalog rules into an efficient specialized implementation with guaranteed worstcase time and space complexities, and for computing the complexities from the rules. The running time is optimal in the sense that only useful combinations ..."
Abstract

Cited by 30 (12 self)
 Add to MetaCart
(Show Context)
This paper describes a method for transforming any given set of Datalog rules into an efficient specialized implementation with guaranteed worstcase time and space complexities, and for computing the complexities from the rules. The running time is optimal in the sense that only useful combinations of facts that lead to all hypotheses of a rule being simultaneously true are considered, and each such combination is considered exactly once. The associated space usage is optimal in that it is the minimum space needed for such consideration modulo scheduling optimizations that may eliminate some summands in the space usage formula. The transformation is based on a general method for algorithm design that exploits fixedpoint computation, incremental maintenance of invariants, and combinations of indexed and linked data structures. We apply the method to a number of analysis problems, some with improved algorithm complexities and all with greatly improved algorithm understanding and greatly simplified complexity analysis.
Parametric regular path queries
 In PLDI ’04: Proceedings of the ACM SIGPLAN 2004 conference on Programming Language Design and Implementation
, 2004
"... Regular path queries are a way of declaratively expressing queries on graphs as regularexpressionlike patterns that are matched against paths in the graph. There are two kinds of queries: existential queries, which specify properties about individual paths, and universal queries, which specify pro ..."
Abstract

Cited by 25 (4 self)
 Add to MetaCart
(Show Context)
Regular path queries are a way of declaratively expressing queries on graphs as regularexpressionlike patterns that are matched against paths in the graph. There are two kinds of queries: existential queries, which specify properties about individual paths, and universal queries, which specify properties about all paths. They provide a simple and convenient framework for expressing program analyses as queries on graph representations of programs, for expressing verification (modelchecking) problems as queries on transition systems, for querying semistructured data, etc. Parametric regular path queries extend the patterns with variables, called parameters, which significantly increase the expressiveness by allowing additional information along single or multiple paths to be captured and related. This paper shows how a variety of program analysis and modelchecking problems can be expressed easily and succinctly using parametric regular path queries. The paper describes the specification, design, analysis, and implementation of algorithms and data structures for efficiently solving existential and universal parametric regular path queries. Major contributions include the first complete algorithms and data structures for directly and efficiently solving existential and universal parametric regular path queries, detailed complexity analysis of the algorithms, detailed analytical and experimental performance comparison of variations of the algorithms and data structures, and investigation of efficiency tradeoffs between different formulations of queries. Categories and Subject Descriptors D.2.4 [Software Engineering]: Software/Program verification—model
Incremental Execution of Transformation Specifications
 IN PROCEEDINGS OF THE 31ST ACM SIGPLANSIGACT SYMPOSIUM ON PRINCIPLES OF PROGRAMMING LANGUAGES
, 2004
"... We aim to specify program transformations in a declarative style, and then to generate executable program transformers from such specifications. Many transformations require nontrivial program analysis to check their applicability, and it is prohibitively expensive to rerun such analyses after eac ..."
Abstract

Cited by 18 (1 self)
 Add to MetaCart
We aim to specify program transformations in a declarative style, and then to generate executable program transformers from such specifications. Many transformations require nontrivial program analysis to check their applicability, and it is prohibitively expensive to rerun such analyses after each transformation. It is desirable, therefore, that the analysis information is incrementally updated. We achieve this by drawing on two pieces of previous work: first, Bernhard Steffen's proposal to use model checking for certain analysis problems, and second, John Conway's theory of language factors. The first allows the neat specification of transformations, while the second opens the way for an incremental implementation. The two ideas are linked by using regular patterns instead of Steffen's modal logic: these patterns can be viewed as queries on the set of program paths.
Composing sourcetosource dataflow transformations with rewriting strategies and dependent dynamic rewrite rules
 14TH INTERNATIONAL CONFERENCE ON COMPILER CONSTRUCTION (CC’05), VOLUME 3443 OF LECTURE NOTES IN COMPUTER SCIENCE
, 2004
"... Dataflow transformations used in optimizing compilers are also useful in other programming tools such as code generators, aspect weavers, domain and applicationspecific optimizers, and refactoring tools. These applications require sourcetosource transformations rather than transformations on ..."
Abstract

Cited by 15 (8 self)
 Add to MetaCart
Dataflow transformations used in optimizing compilers are also useful in other programming tools such as code generators, aspect weavers, domain and applicationspecific optimizers, and refactoring tools. These applications require sourcetosource transformations rather than transformations on a lowlevel intermediate representation. In this paper we describe the composition of sourcetosource dataflow transformations in the program transformation language Stratego. The language supports the highlevel specification of transformations by means of rewriting strategy combinators that allow a natural modeling of data and controlflow without committing to a specific source language. Dataflow facts are propagated using dynamic rewriting rules. In particular, we introduce the concept of dependent dynamic rewrite rules, for modeling the dependencies of dataflow facts on program entitities such as variables. The approach supports the combination of analysis and transformation, the combination of multiple transformations, the combination with other types of transformations, and the correct treatment of variable binding constructs and lexical scope to avoid variable capture.
RDF with regular expressions
 Research report 6191, INRIA RhôneAlpes, Grenoble (FR
, 2007
"... apport de recherche ..."
Correctness of Classical Compiler Optimizations using CTL
 In Proc. of Compiler Optimization meets Compiler Verificaiton (COCV) 2002, Electronic Notes in Theoretical Computer Science (ENTCS
, 2001
"... ..."
Querying Complex Graphs
 Proceedings of the Eighth Intl Symposium on Practical Aspects of Declarative Languages (PADL
, 2006
"... Abstract. This paper presents a powerful language for querying complex graphs and a method for generating efficient implementations that can answer queries with complexity guarantees. The graphs may have edge labels that may have parameters, and easily and naturally capture complex interrelated obje ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
(Show Context)
Abstract. This paper presents a powerful language for querying complex graphs and a method for generating efficient implementations that can answer queries with complexity guarantees. The graphs may have edge labels that may have parameters, and easily and naturally capture complex interrelated objects in objectoriented systems and XML data. The language is built on extended regular path expressions with variables and scoping, and can express queries more easily and clearly than previous query languages. The method for implementation first transforms queries into Datalog with limited extensions. It then extends a previous method to generate specialized algorithms and complexity formulas from Datalog with these extensions. 1
IterativeFree Program Analysis
 In Proc. of Intl. Conference on Functional Programming
, 2003
"... flow analyses are reduced to the problem of finding a fixed point in a certain transition system, and such fixed point is commonly computed through an iterative procedure that repeats tracing until convergence. ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
flow analyses are reduced to the problem of finding a fixed point in a certain transition system, and such fixed point is commonly computed through an iterative procedure that repeats tracing until convergence.
Graph Queries through Datalog Optimizations
, 2010
"... This paper describes the use of a powerful graph query language for querying programs, and a novel combination of transformations for generating efficient implementations of the queries. The language supports graph path expressions that allow convenient use of both vertices and edges of arbitrary ki ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
This paper describes the use of a powerful graph query language for querying programs, and a novel combination of transformations for generating efficient implementations of the queries. The language supports graph path expressions that allow convenient use of both vertices and edges of arbitrary kinds as well as additional global and local parameters in graph paths. Our implementation method combines transformation to Datalog, recursion conversion, demand transformation, and specialization, and finally generates efficient analysis programs with precise complexity guarantees. This combination improves an O(V E) time complexity factor using previous methods to O(E), where V and E are the numbers of graph vertices and edges, respectively. We also describe implementations and experiments that confirm the analyzed complexities.
Reasoning over the Evolution of Source Code using Quantified Regular Path Expressions
"... Abstract—Version control systems (VCS) have become indispensable to develop software. Next to their immediate advantages, they also offer information about the evolution of software and its development process. Despite this wealth of information, it has only been leveraged by tools that are dedicate ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract—Version control systems (VCS) have become indispensable to develop software. Next to their immediate advantages, they also offer information about the evolution of software and its development process. Despite this wealth of information, it has only been leveraged by tools that are dedicated to a specific software engineering task such as predicting bugs or identifying hotspots. Generalpurpose tool support for reasoning about the information contained in a version control system is limited. In this paper, we introduce the logicbased program query language ABSINTHE. It supports querying versioned software systems using logic queries in which quantified regular path expressions are embedded. These expressions lend themselves to specifying the properties that each individual version in a sequence of successive software versions ought to exhibit. I.